Разработка инструмента очистки информации на изображениях не соответствующей заданным паттернам с помощью методов OpenCV.¶
Техническое задание (вводная информация):¶
Проблема: Очистка шума и лишней информации при детекции структурых элементов на фотографиях
Простейший случай - pdf файла отсканированных документов и получение границ таблицы
План работы (1 семестр):
- Поискать готовые работы как решали нашу проблему. (scholar)
Результат - это от 20 просмотренных работ (работы не старше 2019 года), и от 5 релевантных работ по теме (где рассмотрены подходы по теме)
- Попробовать запустить код с opencv и тех подходов, которые будут найдены.
Результат: подходы (от 3-х подходов), и по каждому подходу оценка качества его работы (визуальная и численная)
- GAN (generative adversarial networks), CNN, RCNN - если есть исследования с этими инструментами - их обязательно нужно рассмотреть.
Что такое GAN, CNN и RCNN.¶
GAN (Generative Adversarial Networks)
Генеративные состязательные сети (GAN) — это архитектура нейронных сетей, где две сети (генератор и дискриминатор) обучаются одновременно, состязаясь друг с другом.
Как это работает?
Генератор (Generator):
Создает изображения или данные, которые должны быть похожи на реальные.
Его цель — "обмануть" дискриминатор, создавая данные, которые выглядят правдоподобно.
Дискриминатор (Discriminator):
Ставит цель отличить реальные данные от поддельных, созданных генератором.
Его задача — максимально точно распознавать "фейковые" данные.
Генератор улучшает свои результаты, пока дискриминатор не сможет больше отличать подделку от реальности.
Пример применения:
- Удаление шума из изображений (Image Denoising):
GAN используется для восстановления изображения, удаляя шум и восстанавливая детали.
- Генерация изображений:
Создание реалистичных лиц, пейзажей, объектов.
Например, StyleGAN — технология, генерирующая фотореалистичные изображения людей.
- Дополнение данных:
Увеличение объема обучающей выборки путем генерации данных, похожих на реальные.
CNN (Convolutional Neural Networks)
Сверточные нейронные сети (CNN) — это тип нейронных сетей, который особенно хорошо работает с изображениями и данными, где важна пространственная структура.
Как это работает?
Основной элемент CNN — свертка (convolution):
На изображении выделяются локальные паттерны, такие как линии, углы или текстуры.
Свертки сканируют изображение и извлекают ключевые признаки.
Архитектура включает:
Сверточные слои для выделения признаков.
Пулинг-слои для уменьшения размера данных (например, MaxPooling).
Полносвязные слои для классификации.
Пример применения:
- Классификация изображений:
Определение, что изображено на картинке (например, распознавание кошек и собак).
Например, AlexNet, VGG, ResNet — популярные архитектуры CNN.
- Обнаружение объектов (Object Detection):
Определение местоположения объектов на изображении (например, авто на дороге).
- Сегментация изображений:
Разделение изображения на области (например, разделение фона и объекта).
RCNN (Region-based Convolutional Neural Networks)
RCNN (Region-based CNN) — это модификация CNN, предназначенная для обнаружения объектов на изображениях.
Как это работает?
RCNN включает три ключевых этапа:
- Выделение областей-кандидатов (Region Proposal):
Изображение разбивается на множество областей (ROI — Regions of Interest), где могут находиться объекты.
- Применение CNN:
Для каждой области применяется сверточная сеть, чтобы определить, содержит ли она объект и какой именно.
- Классификация:
Каждая область классифицируется, и определяются границы объекта.
Пример применения:
- Обнаружение объектов:
Классический пример — RCNN используется для обнаружения автомобилей, пешеходов или других объектов в видео и на изображениях.
- Улучшенные версии:
Fast RCNN: Ускоренная версия, где свертки применяются ко всему изображению, а не к каждой области.
Faster RCNN: Еще быстрее, так как использует Region Proposal Network (RPN) для поиска областей.
Сайты для поиска информации¶
https://scholar.google.com/ - для поиска научных статей
https://beta.theb.ai/home - chatgpt
https://huggingface.co/ - репозиторий обученных моделей
https://roboflow.com/ - тут тоже есть много веселых моделей
Анализ и ревью кода¶
block_size: int = 15
img: numpy.ndarray
block_size — это целочисленная переменная, которая задает размер окна для адаптивного порогового преобразования (adaptive thresholding). Он должен быть нечетным числом (например, 15).
img — это входное изображение, представленное как numpy массив. Предполагается, что изображение уже загружено и находится в формате BGR (синий, зеленый, красный).
# convert BGR to Binary
#Преобразование с RGB в серый цвет
gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
#Инверсия цветов
gray = cv2.bitwise_not(gray)
#Адаптивное пороговое преобразование
bw = cv2.adaptiveThreshold(
gray, # Входное изображение в оттенках серого
255, # Максимальное значение для белых пикселей
cv2.ADAPTIVE_THRESH_MEAN_C, # Метод вычисления порога
cv2.THRESH_BINARY, # Тип порогового преобразования
block_size, # Размер блока для вычисления локального порога
-2) # Константа, вычитаемая из среднего значения
--------------------------------------------------------------------------- NameError Traceback (most recent call last) <ipython-input-12-c678eb6400e1> in <cell line: 2>() 1 block_size: int = 15 ----> 2 img: numpy.ndarray 3 4 # convert BGR to Binary 5 gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY) NameError: name 'numpy' is not defined
Адаптивное пороговое преобразование — это метод преобразования изображения в бинарное (черно-белое), который учитывает локальные особенности изображения для определения порога яркости. Это особенно полезно для изображений с неравномерным освещением или тенями, где использование простого порога может привести к потере информации. Текст, выделенный полужирным шрифтом Адаптивное пороговое преобразование решает проблему неравномерного освещения, вычисляя порог для каждой небольшой области изображения (блока) отдельно.
Преимущества адаптивного порогового преобразования Устойчивость к изменениям освещения: Работает даже в случае неравномерного освещения и теней. Локальное выделение деталей: Подходит для изображений с мелкими элементами и сложной структурой, например, для таблиц или документов.
# apply a horizontal kernel to detect all the horizontal lines from the image
kernel = np.ones((1, bw.shape[1] // 2), np.uint8)
horizontal = cv2.erode(bw, kernel)
horizontal = cv2.dilate(horizontal, kernel)
np.ones() — функция для создания ядра (kernel) из единиц.
Размер ядра: (1, bw.shape[1] // 2) означает, что у ядра 1 строка и половина ширины изображения.
Тип данных — np.uint8 (8-битные целые числа).
Мы создаем горизонтальное ядро, состоящее из одной строки и большого количества столбцов (половина ширины изображения). Это ядро будет чувствительно только к горизонтальным линиям и игнорировать вертикальные элементы.
cv2.erode() — это функция для эрозии изображения.
Эрозия уменьшает белые области на изображении, т.е. сужает линии и удаляет мелкие объекты.
В данном случае мы применяем горизонтальное ядро, поэтому сужение происходит только по горизонтали.
Если горизонтальная линия слишком короткая (меньше половины ширины изображения), она исчезнет. Это помогает фильтровать шум и мелкие горизонтальные элементы, оставляя только длинные линии.
cv2.dilate() — это функция для дилатации изображения.
Дилатация увеличивает белые области, т.е. расширяет линии и восстанавливает их до исходной толщины.
Опять же, за счет использования горизонтального ядра расширение происходит только в горизонтальном направлении.
В результате, длинные горизонтальные линии, которые остались после эрозии, будут восстановлены до их исходной толщины, а мелкие элементы останутся удаленными.
Перечень работ, связанных с темой "Разработка инструмента очистки информации на изображениях не соответвующей заданным паттернам с помощью методов OpenCV."¶
В данном разделе представлены работы, связанные с нашей проблемой и которые напрямую или частично соответствуют теме нашей работы. Разделы "Аннотация" и "Заключение" деблированы (переведены) с работ. В разделе "Анализ работы" приведен краткий обзор работы с заключением в части использования материала для решения нашей задачи.
Запросы для поиска информации на английском языке¶
Основные запросы:
"Noise removal and irrelevant information filtering in structural element detection"
"Efficient noise removal methods for detecting structural elements in images"
"Deep learning approaches for noise reduction and structural element detection"
"Image preprocessing techniques for structural element extraction"
"Filtering noise and artifacts in document structure detection"
Уточняющие запросы с использованием методов:
"GAN-based noise removal in image structure detection"
"CNN methods for noise reduction in image segmentation tasks"
"RCNN for structural element detection and noise filtering"
"Adaptive preprocessing for noise-free detection of structural elements"
"Machine learning techniques for noise reduction in structural feature extraction"
Для поиска статей на пересечении с областями применения:
"Noise removal in table and grid detection in scanned documents"
"Deep learning for line detection and noise elimination in document images"
"Artifact reduction in image preprocessing for OCR systems"
"Image denoising for architectural or structural design analysis"
Для поиска актуальных решений:
"Recent advances in noise reduction and structural feature extraction"
"Open source tools for noise filtering in structural element recognition"
"Combining GAN and CNN for noise removal in document analysis"
Запросы для поиска информации на русском языке¶
Основные запросы:
"Удаление шума и фильтрация лишней информации при детекции структурных элементов"
"Методы очистки изображений от шума для выделения структурных элементов"
"Обработка изображений для удаления артефактов и лишних данных"
"Алгоритмы устранения шумов при распознавании структурных элементов"
"Предобработка изображений для выделения структурных объектов"
Запросы с использованием современных методов:
"GAN для удаления шума и выделения структурных элементов"
"Применение сверточных нейронных сетей для фильтрации шума на изображениях"
"RCNN для детекции структурных элементов с удалением артефактов"
"Глубокое обучение для очистки изображений и выделения структурных данных"
"Методы машинного обучения для устранения шума при выделении объектов"
Уточненные запросы для разных областей применения:
"Удаление артефактов и шумов при анализе таблиц и документов"
"Детекция линий и структурных объектов на изображениях с фильтрацией шума"
"Обработка сканов документов для удаления лишней информации"
"Методы очистки архитектурных изображений от шума"
"Фильтрация шумов на технических чертежах и документации"
Для поиска конкретных методов:
"Сравнение методов удаления шума при обработке изображений"
"Использование GAN для очистки и выделения линий на изображениях"
"Морфологические операции и их замена нейросетями в обработке изображений"
1. Morphological filter detector for image forensics applications¶
Работа, переведенная при помощи Google Translate: Открыть
Ссылка на источник: https://ieeexplore.ieee.org/abstract/document/8955879
Аннотация:
Математическая морфология предоставляет широкий набор мощных нелинейных операторов обработки изображений, широко используемых для выделения признаков, удаления шума или улучшения изображений. Хотя морфологические фильтры могут использоваться для удаления артефактов, возникающих при манипуляциях с изображениями как на бинарных, так и на градациях серого, уделено мало внимания их судебной идентификации. В данной работе мы предлагаем нетривиальное расширение детерминированного подхода, первоначально предназначенного для обнаружения эрозии и дилатации бинарных изображений. Предложенный подход работает с изображениями в градациях серого и устойчив к сжатию изображений и другим типичным атакам. Когда изображение подвергается атаке, метод теряет свою детерминированную природу и использует правильно обученный классификатор SVM, используя исходный детектор в качестве извлекателя признаков. Обширные тесты демонстрируют, что предложенный метод гарантирует очень высокую точность обнаружения фильтрации, обеспечивая 100% точность в различении наличия и типа морфологического фильтра в необработанных изображениях из трёх различных наборов данных. Достигнутая точность также хороша после сжатия JPEG, равная или выше 76,8% во всех наборах данных для коэффициентов качества выше 80. Предложенный подход также способен определить используемый структурирующий элемент для умеренных коэффициентов сжатия. Наконец, он устойчив к добавлению шума и может отличить морфологический фильтр от других фильтров.
Заключение:
В данной работе мы предлагаем эффективную стратегию обнаружения для оценки использования морфологической фильтрации в контексте градаций серого. Мы рассматриваем несжатые изображения, предлагая детерминированный подход, основанный на математических свойствах, присущих базовым морфологическим операторам. Дополнительно мы предлагаем модифицированный конвейер для обнаружения морфологической обработки в сжатых изображениях, используя информацию гистограммы разностей в качестве признака для классификации. Мы представляем фазу тестирования, в которой учитываются как несжатые, так и сжатые сценарии. Результаты показывают эффективность нашего предложенного подхода в обоих случаях. Более того, предложенный подход способен определить используемый структурирующий элемент для умеренных коэффициентов сжатия и устойчив к ряду атак.
Анализ работы:
Цель исследования:
Разработка метода детекции морфологических фильтров (эрозии, дилатации) на изображениях, включая как необработанные, так и подвергнутые постобработке изображения (например, сжатие, добавление шума).
Метод, применяемый в работе:
SVM с ядром RBF для классификации.
Результаты исследования:
Метод продемонстрировал высокую точность на необработанных изображениях (100%). Для сжатых изображений (JPEG, QF ≥ 80) точность выше 76.8%. Метод также показал устойчивость к добавлению шума (например, Gaussian, Pepper & Salt).
Заключение:
Подход из статьи можно адаптировать для удаления шума и выделения структурных элементов на изображениях. Применять эрозию и дилатацию для фильтрации лишней информации (линий или текстур), но с учетом их последующей классификации. Выбор SVM с ядром RBF как классификатора подтверждает, что этот метод хорошо подходит для задач классификации структурных элементов или оценки эффекта фильтрации.
Для оценки качества фильтрации (проверки, были ли удалены шумы или нежелательные линии) будет полезно использовать идею анализа гистограмм разности между исходным и обработанным изображением.
2. Deep Learning Based Noise Reduction for Brain MR Imaging Tests on Phantoms and Healthy Volunteers¶
Работа, переведенная при помощи Google Translate: Открыть
Цель:
Проверить, может ли предлагаемая нами методика по снижению шума с использованием реконструкции на основе глубокого обучения (dDLR) эффективно подавлять шум на МР-изображениях головного мозга.
Методы: Текст, выделенный полужирным шрифтом В начальном экспериментальном исследовании мы получили МР-изображения головного мозга от пяти добровольцев и добавили различные уровни искусственного шума. Для подавления шума модифицированные изображения обработали с помощью сверточной нейронной сети для шумоподавления (DnCNN), сверточной нейронной сети с сжатием (SCNN) и dDLR. Используя эти МР-изображения головного мозга, мы сравнили индекс структурного сходства (SSIM) и отношение сигнал/шум (PSNR) между тремя методами подавления шума. Два нейрорадиолога оценили качество изображений трёх типов. В клиническом исследовании мы оценили эффект подавления шума dDLR на МР-изображениях головного мозга с различными уровнями фактического шума, таким как тепловой шум. В частности, мы получили 2D-T2-взвешенные изображения, 2D-FLAIR (флюид-ослабленная инверсионная реконструкция) и 3D-MPRAGE (магнитно-направленная быстрая последовательная приобретение с градиентным эхом) от 15 здоровых добровольцев при двух различных настройках количества приобретений изображений (NAQ): NAQ2 и NAQ5. Мы реконструировали dDLR-обработанные NAQ2 из NAQ2, затем сравнили с SSIM и PSNR. Два нейрорадиолога отдельно оценили качество изображений NAQ5, NAQ2 и dDLR-NAQ2. Статистический анализ был проведён как в экспериментальном, так и в клиническом исследовании. В клиническом исследовании также оценивалась согласованность между наблюдателями.
Результаты:
В экспериментальном исследовании PSNR и SSIM для dDLR были статистически выше, чем у DnCNN и SCNN (P < 0,001). Качество изображений dDLR также превосходило качество DnCNN и SCNN. В клиническом исследовании dDLR-NAQ2 было значительно лучше, чем изображения NAQ2 по показателям SSIM и PSNR во всех трёх последовательностях (P < 0,05), за исключением PSNR в FLAIR. Для всех качественных показателей dDLR-NAQ2 имело эквивалентное или лучшее качество изображений, чем NAQ5, и превосходное качество по сравнению с NAQ2 (P < 0,05) для всех критериев, кроме артефактов. Согласованность между наблюдателями варьировалась от существенной до почти идеальной.
Заключение:
dDLR снижает шум на изображениях, сохраняя качество изображений головного мозга на МР-изображениях.
Анализ работы:
В статье предложен метод глубокого обучения для удаления шума из изображений dDLR, который показал хорошие результаты по сравнению с другими методами (DnCNN и SCNN). Метод основан на разделении изображения на низкочастотные и высокочастотные компоненты с помощью дискретного косинусного преобразования (DCT). Высокочастотные компоненты, содержащие шум и мелкие детали, обрабатываются CNN с использованием soft-shrinkage функции активации. Этот подход позволяет адаптивно удалять шум, сохраняя ключевые структурные элементы изображения.
Для нашей научной работы метод dDLR представляет интерес по нескольким причинам. Во-первых, его способность эффективно выделять и очищать высокочастотные компоненты изображения подходит для задач удаления лишней информации, например, текстур или шумов, не соответствующих заданным паттернам. Во-вторых, использование DCT позволяет сохранить структурные элементы изображения, что важно при обработке сложных визуальных данных, таких как архитектурные или биологические структуры.
3. Restormer: Efficient Transformer for High-Resolution Image Restoration (есть модель)¶
Работа, переведенная при помощи Google Translate: Открыть
Аннотация:
Поскольку сверточные нейронные сети (CNN) хорошо справляются с обучением обобщаемых предварительных знаний об изображениях из масштабных данных, эти модели широко применяются для восстановления изображений и связанных задач. В последнее время другой класс нейронных архитектур, трансформеры, показал значительное улучшение производительности в задачах обработки естественного языка и высокоуровневого видения. Хотя модель трансформера устраняет недостатки CNN (т.е. ограниченное поле восприятия и неадаптируемость к содержимому входных данных), её вычислительная сложность растёт квадратично с увеличением пространственного разрешения, что делает её неприменимой для большинства задач восстановления изображений с участием изображений высокого разрешения. В данной работе мы предлагаем эффективную модель трансформера, разработав несколько ключевых элементов в блоках (многоголовочное внимание и полносвязная сеть), что позволяет захватывать дальнодействующие взаимодействия пикселей, при этом оставаясь применимой к большим изображениям. Наша модель, названная Restoration Transformer (Restormer), достигает передовых результатов в нескольких задачах восстановления изображений, включая удаление дождя с изображений, размытие движения на одном изображении, размытие из-за расфокусировки (на основе данных одного изображения и данных с двойными пикселями) и удаление шума на изображениях (удаление гауссового шума в градациях серого и цвета, а также удаление шума на реальных изображениях). Исходный код и предобученные модели доступны по адресу https://github.com/swz30/Restormer.
Заключение:
Мы представляем модель трансформера для восстановления изображений, Restormer, которая является вычислительно эффективной для обработки изображений высокой разрешающей способности. Мы вводим ключевые изменения в основные компоненты блока трансформера для улучшенной агрегации и трансформации признаков. В частности, наш модуль многоголовочного транспонированного внимания с глубокой сверткой (MDTA) неявно моделирует глобальный контекст, применяя самовнимание по каналам, а не по пространственному измерению, что обеспечивает линейную сложность вместо квадратичной. Кроме того, предложенная полносвязная сеть с затвором на основе глубокой свертки (GDFN) вводит механизм затворов для контролируемой трансформации признаков. Чтобы интегрировать преимущества CNN в модель трансформера, оба модуля MDTA и GDFN включают свёртки по глубине для кодирования пространственно локального контекста. Обширные эксперименты на 16 эталонных наборах данных демонстрируют, что Restormer достигает передовых результатов для множества задач восстановления изображений.
Анализ работы:
Данная статья предлагает современные методы обработки изображений, которые могут быть адаптированы для очистки информации, не соответствующей заданным паттернам. Основное внимание уделяется восстановлению изображений высокого разрешения, включая устранение шума, размытия и других артефактов.
Ключевым элементом Restormer является модуль MDTA, который позволяет моделировать как локальные, так и глобальные взаимосвязи пикселей. Это может быть полезно в нашей задаче, так как обработка структурных элементов изображения требует учета как локального контекста, так и общей структуры изображения. Кроме того, механизм "gated feed-forward network" (GDFN) предоставляет средства для фильтрации менее значимых признаков и выделения важных деталей, что также может быть применено для удаления ненужной информации.
4. GAN-based Noise Model for Denoising Real Images (есть модель)¶
Открыть работу GAN-based_Noise_Model_for_Denoising_Real_Images.pdf
Работа, переведенная при помощи Google Translate: Открыть
Аннотация:
В настоящей работе мы предлагаем новый подход к моделированию реалистичного шума изображений на основе генеративной состязательной сети (GAN). Цель модели — повысить эффективность глубокой нейронной сети для удаления шума в реальных условиях. Хотя глубокие нейронные сети для удаления шума, такие как сверточные нейронные сети для шумоподавления, могут достигать передовых результатов на синтетических шумах, их эффективность значительно снижается при работе с реальными зашумленными изображениями. Для решения этой проблемы мы предлагаем двухэтапную модель. Сначала изображения преобразуются в сырые данные перед добавлением шума. Затем мы обучили GAN для оценки распределения шума на большом наборе изображений (1 миллион). Оцененный шум использовался для обучения глубокой нейронной сети для удаления шума. Обширные эксперименты продемонстрировали, что наша новая модель шума достигает передовых результатов на реальных сырых изображениях из набора данных Smartphone Image Denoising Dataset.
Заключение:
В настоящей работе мы представляем модель на основе GAN для оценки реального шума в сырых данных изображений. Модель состоит из процесса «разобработки» для преобразования изображений из цветового пространства sRGB в сырые данные изображений. Используя сгенерированный шум, мы можем создать большое количество данных для обучения глубокой нейронной сети (DNN). Хотя наш подход имеет некоторые ограничения, такие как зависимость от предварительных статистических данных, хранящихся в метаданных, и приближения уровня шума, экспериментальные результаты демонстрируют эффективность нашего подхода к увеличению данных для удаления шума с реальных изображений.
Анализ работы:
В работе рассматривается подход, основанный на генеративно-состязательных сетях (GAN), для моделирования реалистичного шума и последующего обучения нейронных сетей для очистки изображений. Основное внимание уделяется созданию пар «зашумлённое изображение — чистое изображение» для тренировки денойзеров, таких как DnCNN и UNet, что позволяет эффективно справляться с реальными шумами, часто отличающимися от синтетических.
Для нашей задачи статья может быть полезна в аспекте моделирования и генерации шума. Использование GAN для создания синтетических данных позволяет получить высокореалистичные модели шума, которые могут быть применены для тестирования или обучения алгоритмов, очищающих изображения.
5. Image Denoising with GAN Based Model¶
Открыть работу Image_Denoising_with_GAN_Based_Model.pdf
Работа, переведенная при помощи Google Translate: Открыть
Аннотация:
Удаление шума с изображений часто используется в качестве предварительного этапа в задачах компьютерного зрения, что может помочь повысить точность моделей обработки изображений. Из-за несовершенства систем получения изображений, передающих сред и записывающего оборудования цифровые изображения часто загрязняются различными шумами во время их формирования, что ухудшает визуальные эффекты и даже затрудняет нормальное распознавание людьми. Загрязнение шумом напрямую влияет на обработку таких задач, как обнаружение краев изображения, выделение признаков, распознавание образов и другие, что затрудняет преодоление узких мест путем модификации модели. Многие традиционные методы фильтрации показывают плохие результаты, поскольку они не обладают оптимальной выразительностью и адаптивностью для конкретных изображений. В то же время технологии глубокого обучения открывают новые возможности для удаления шума с изображений. В данной работе мы предлагаем новую нейронную сеть, основанную на генеративных состязательных сетях (GAN) для удаления шума с изображений. Вдохновленные архитектурой U-Net, наш метод использует новую симметричную генераторную сеть на основе энкодера-декодера. Энкодер использует сверточные нейронные сети для извлечения признаков, в то время как декодер выводит шум на изображениях с помощью де-сверточных нейронных сетей. Особо отмечается добавление соединений (shortcuts) между определенными слоями, что позволяет сохранять текстурные детали изображения и предотвращать взрывы градиентов. Кроме того, для улучшения стабильности обучения модели мы добавляем расстояние Васерштейна в функцию потерь в качестве оптимизации. Мы используем отношение пиковой мощности к шуму (PSNR) для оценки нашей модели и можем подтвердить её эффективность с помощью экспериментальных результатов. В сравнении с передовыми подходами наш метод демонстрирует конкурентоспособную производительность.
Заключение:
В данной работе мы предложили новую модель на основе GAN для удаления шума с изображений. С помощью новой генераторной сети предлагаемая модель обеспечивает более эффективный и универсальный метод удаления шума с изображений и может быть легко обучена для компенсации шума на изображениях. Результаты экспериментов показывают эффективность нашей предложенной модели. Мы считаем, что есть возможности для дальнейшего улучшения экспериментальных результатов. В настоящее время потеря насыщенности цвета, вызванная нашей моделью, несколько высока. В то же время мы также рассматриваем, могут ли методы снижения шума на основе GAN иметь более широкие применения, чем методы на основе CNN или традиционные методы, что может стать направлением наших будущих исследований.
Анализ работы:
В статье рассматривается использование генеративно-состязательных сетей (GAN) для устранения шума на изображениях с акцентом на сохранение деталей и стабильность обучения. Основной архитектурой является симметричная сеть "кодировщик-декодировщик", основанная на U-net, которая обеспечивает эффективное извлечение признаков шума и его удаление. Это достигается за счет сочетания сверточных слоев для кодирования изображения и деконволюционных слоев для декодирования и восстановления исходного изображения. Такой подход позволяет сохранить текстурные детали, что может быть полезным для задач, связанных с выделением структурных элементов.
Использование Wasserstein GAN с градиентным штрафом (WGAN-GP) в качестве основы для обучения модели является ключевой инновацией статьи. Эта модификация функции потерь обеспечивает стабильность обучения, избегая таких проблем, как градиентный взрыв или исчезновение. Данная методика позволяет повысить качество восстановления изображения, особенно в условиях сложных шумовых моделей.
6. GRDN: Grouped Residual Dense Network for Real Image Denoising and GAN-based Real-world Noise Modeling¶
Работа, переведенная при помощи Google Translate: Открыть
Аннотация:
Недавние исследования в области удаления шума с изображений продвинулись благодаря развитию архитектур глубокого обучения, особенно сверточных нейронных сетей. Однако удаление шума с реальных изображений по-прежнему остаётся очень сложной задачей, поскольку невозможно получить идеальные пары изображений с истинными данными и реальными зашумленными изображениями. В связи с недавним выпуском эталонных наборов данных интерес сообщества, занимающегося удалением шума с изображений, теперь смещается в сторону проблемы удаления шума в реальных условиях. В этой статье мы предлагаем группированную остаточно-плотную сеть (GRDN), которая является расширенной и обобщённой архитектурой передовой остаточно-плотной сети (RDN). Основная часть RDN определяется как группированный остаточно-плотный блок (GRDB) и используется в качестве строительного модуля GRDN. В экспериментальных исследованиях мы показываем, что производительность удаления шума с изображений может быть значительно улучшена за счёт каскадного соединения GRDB. Помимо разработки архитектуры сети, мы также разработали новый метод моделирования реального шума на основе генеративной состязательной сети (GAN). Мы демонстрируем превосходство предложенных методов, достигая наивысших показателей как по отношению пиковой мощности к шуму (PSNR), так и по индексу структурного сходства (SSIM) в соревновании NTIRE2019 Real Image Denoising Challenge - Track 2: sRGB.
Заключение:
В этой статье мы предложили улучшенную архитектуру сети для удаления шума с реальных изображений. Широкое и иерархическое использование остаточных соединений позволило нашей модели достичь передовых результатов. Кроме того, мы разработали улучшенный метод моделирования реального шума на основе GAN. Хотя мы смогли оценить предложенную сеть только для задачи удаления шума с реальных изображений, мы считаем, что предложенная сеть обладает общей применимостью. Поэтому мы планируем применить предложенную сеть для удаления шума к другим задачам восстановления изображений. Мы также не смогли полностью и количественно обосновать эффективность предложенного метода моделирования реального шума. Для лучшего моделирования реального шума необходим более продуманный дизайн. Мы уверены, что наш метод моделирования реального шума может быть расширен для других реальных деградаций, таких как размытие, алиасинг и дымка, что будет продемонстрировано в наших будущих работах.
Анализ работы:
В данной работе представлены ценные подходы для устранения шума и улучшения качества изображений с использованием глубоких нейросетей. Архитектура GRDN, основанная на группированных остаточных плотных блоках (GRDB), показывает высокую эффективность в задачах денойзинга благодаря каскадному соединению блоков, использованию глобальных остаточных соединений и модулей внимания (CBAM). Эти элементы могут быть полезны для нашей работы, так как позволяют сохранять текстурные детали и эффективно выделять шум, что соответствует задаче выделения структурных элементов изображения.
Кроме того, использование GAN для генерации реалистичного шума дает возможность создавать качественные тренировочные наборы для обучения моделей. Таким образом, архитектура GRDN и методы генерации шума из статьи могут быть применимы для разработки инструмента очистки изображений, который будет учитывать как реальные, так и синтетические сценарии.
7. Cпособ оценки четкости фотореалистичных изображений¶
Открыть работу Cпособ_оценки_четкости_фотореалистичных_изображений.pdf
Аннотация:
В статье предлагается способ оценки четкости фотореалистичных изображений, осно- ванный на сравнении коэффициента детальности оригинального и искаженного изображений. В алгоритме идентификации мелких структур оригинального изображения используются операции сегментации активных пикселей, к которым относятся точечные объекты, тонкие линии и фрагменты текстуры. Количество активных пикселей оценивается значением коэффициента детальности, которое определяется отношением активных пикселей к общему количеству пикселей изображения. Этот же алгоритм используется для вычисления значения коэффициента детальности искаженного изображения, и далее оценивается снижение четкости с помощью сравнения полученных значений. К особенностям способа относится то, что идентификация мелких структур и сегментация активных пикселей выполняется в нормированной системе N-CIELAB.Также в алгоритме учитывается влияние ложных микроструктур на результаты оценки реставрированного изображения. Рассматривают- ся особенности построения нейронных сетей SRCNN в задачах качественного повышения разрешения изображения с восстановлением мелких структур. Приводятся результаты анализа качества увеличенных изображений по традиционным метрикам PSNR и SSIM, а также по предлагаемому способу.
Заключение:
В результате исследований в данной работе получены следующие выводы. Развитие систем искусственного интеллекта с целью улучшения четкости изображения на основе методов SR несомненно является перспективным направлением. Однако традиционные метрики качества реставрированных изображений не позволяют однозначно сопоставить результаты численных оценок с визуальными оценками.
В настоящей работе предложен и описан подход к решению этой проблемы, основанный на оригинальном способе измерения четкости изображения. Оригинальность заключается в том, что по сравнению со стандартным способом измерения разрешения на основе SFR в предлагаемом способе используется алгоритм идентификации активных пикселей эталонного и искаженного изображений с учетом свойств зрительного восприятия контраста мелких деталей и наличия ложных микроструктур. При этом в процессе анализа не требуются тестовые таблицы и используются характеристики фотореалистичных изображений.
Получены численные критерии – относительный коэффициент детальности Rd и коэффициент ложных компонент FDLfalse, по значениям которых можно делать выводы о качестве реставрированного изображения. Чем ближе значение Rd к единице и значение FDLfalse к нулю, тем ближе качество восстановленного изображения к оригинальному.
В частности, для фотореалистичных изображений, сжатых по стандарту JPEG или JPEG2000 с высокими параметрами качествами, эти критерии в среднем соответствуют значениям Rd > 0,95 и FDLfalse < 2 %.
Результаты оценок качества реставрированных HR-изображений (табл. 1) показывают, что существующие методы SR ещё далеки от совершенства. Однако по сравнению с простой бикубической интерполяцией имеют очевидное преимущество. Сохранение более 50 % четкости мелких структур увеличенного изображения с помощью приложения Deep Image – это очень хороший результат.
Анализ работы:
Статья "Способ оценки четкости фотореалистичных изображений с высоким разрешением" представляет методику оценки четкости изображений путем сравнения коэффициента детальности между оригинальным и искаженным изображением. Алгоритм основывается на сегментации активных пикселей, которые включают точечные объекты, тонкие линии и фрагменты текстуры. Коэффициент детальности определяется как отношение числа активных пикселей к общему количеству пикселей изображения. Этот подход используется для оценки искажения изображения и определения степени потери четкости.
Этот метод будет полезен в качестве дополнительной метрики для оценки и сравнения качества изображений, особенно если очистка предполагает удаление или фильтрацию специфической информации.
8. Применение генеративно-состязательных сетей (GAN) в обработке изображений¶
Аннотация: Генеративно-состязательные сети (GAN) стали важным инструментом в области обработки изображений, предлагая новые методы создания и улучшения визуальных данных. В данной статье исследуются принципы работы GAN, их преимущества и ограничения, а также различные применения, включая улучшение качества изображений, создание реалистичных изображений и стилевые трансферты. Особое внимание уделяется архитектурам GAN, таким как DCGAN и CycleGAN, и их роли в развитии глубокого обучения.
Заключение:
Генеративно-состязательные сети (GAN) представляют собой мощный инструмент в области обработки изображений, предлагая новые подходы к созданию и улучшению визуальных данных. Благодаря таким архитектурам, как DCGAN и CycleGAN, стало возможным выполнение задач, ранее недоступных для традиционных методов машинного обучения. Однако, для достижения полного потенциала GAN, необходимо преодолеть существующие вызовы и продолжить исследования в этом направлении.
Анализ работы:
Статья рассматривает роль GAN в улучшении качества и создании изображений. Генеративно-состязательные сети представляют собой мощный инструмент для синтеза и улучшения визуальных данных, применяемый в различных задачах обработки изображений, таких как улучшение качества, создание фотореалистичных изображений и стилевые трансферты. В статье подробно анализируются архитектуры GAN, такие как DCGAN и CycleGAN, и их вклад в развитие методов глубокого обучения. Эти сети могут быть полезны для нашей работы. В отличие от стандартных фильтров, GAN могут применяться для более сложных задач, таких как восстановление утраченных или поврежденных частей изображения, что может быть полезно в процессе очистки изображений, сохраняя их структуру и четкость.
9. Сравнительный анализ двух способов фильтрации для устранения шума в изображениях разной степени зашумленности¶
Аннотация:
В современной технике фото- и видеосъемки любое изображение в процессе его формирования искажается под действием различных видов шумов. Существуют различные виды шумов, но на практике наиболее часто встречаются модели импульсного и гауссовского шума. Ослабление действия шумов достигается путём фильтрации. На данный момент не существует универсального фильтра, подавляющего данные типы шумов при различных интенсивностях искажения. Поэтому важным аспектом является определение области применения каждого вида фильтра при подавлении шумов в изображении и создании типа фильтра, состоящего из синтеза сочетающего различные методы фильтрации для оптимальной очистки изображения. В статье представлен сравнительный анализ медианной фильтрации и фильтрации Винера для устранения импульсного и гауссовского шума в изображении при разной степени зашумленности. Для моделирования использовалось одно изображение, искаженное отдельно импульсным и отдельно гауссовским шумом с вероятностями искажения пикселей от 1 % до 99 % включительно. Фильтрация производилась с окнами, равными 3x3 и 5x5. В результате были получены численные оценки качества фильтрации изображений на основе пикового отношения сигнал-шум (PSNR). На основе полученных данных была проанализирована область применения исследуемых фильтров, их модификации, достоинства и недостатки, а также приведены рекомендации по их использованию. В результате сравнительного анализа исследуемых видов фильтрации для зашумленных изображений было установлено, что медианный фильтр с окном 3х3 лучше справляется с очисткой изображения от импульсного шума малой интенсивности и с окном 5х5 – с очисткой изображения средней интенсивности зашумления. Также медианный фильтр лучше справляется с фильтрацией гауссовского шума при его средних и высоких значениях среднеквадратичного отклонения. Фильтр Винера с окнами 3х3 и 5х5 лучше фильтрует гауссовский шум при малых его значениях его среднеквадратичного отклонения. Также фильтр Винера лучше справляется с импульсным шумом относительно высокой интенсивности зашумления.
Заключение:
В результате применения исследуемых видов фильтраций над зашумленными изображениями установлено, что медианный фильтр с окном 3х3 лучше справляется с очисткой изображения от импульсного шума малой интенсивности (p=0.05…0.1) и с окном 5х5 с очисткой изображения средней интенсивности зашумления (p=0.25…0.75). Также медианный фильтр лучше справляется с фильтрацией гауссовского шума при его средних ( = 25…75) и высоких ( = 90…99) значениях среднеквадратичного отклонения.
Фильтр Винера с окнами 3х3 и 5х5 лучше справляется с фильтрацией гауссовского шума при малых его значениях среднеквадратичного отклонения ( = 1…5). Также фильтр Винера лучше справляется с импульсным шумом высокой интенсивности зашумления (p=0.9…0.99).
Анализ работы:
Статья рассматривает методы фильтрации изображений, предназначенные для устранения различных типов шума, таких как импульсный и гауссовский шум. Основное внимание уделяется медианной фильтрации и фильтрации Винера, сравнивая их эффективность в условиях различных уровней зашумленности. Важно отметить, что в статье рассматривается, как правильно выбирать и сочетать фильтры в зависимости от интенсивности и типа шума, чтобы достичь оптимальных результатов в очистке изображений. Этот анализ может быть полезен для нашей работы, так как фильтрация шума является важным шагом в процессе очистки изображений, и использование методов, таких как медианная фильтрация или фильтрация Винера, может значительно улучшить результаты.
10. Новый метод обнаружения и устранения случайнозначного импульсного шума на изображениях¶
Аннотация:
В работе предложен метод детектирования и последующего устранения импульсного шума на изображениях, в котором вводится понятие сходства между пикселями как функции расстояния и разницы в значениях яркости в локальном окне детектора. Рассматривается модель импульсного шума, в которой искаженные пиксели принимают случайные значения, а также случайным образом возникают на изображении. Пиксели, которые были отмечены как искаженные импульсным шумом, восстанавливаются адаптивным медианным фильтром. Импульсные искажения детектируются в окне детектора, размер которого рассчитан по евклидовой метрике и увеличивается с ростом интенсивности шума на изображении. В экспериментальной части представлено сравнение между известными и предлагаемым методами на трёх изображениях для трех различных интенсивностей импульсного шума. В приближении на фрагментах изображений видно, что предлагаемый метод наилучшим образом справляется с задачей, что было также подтверждено численными оценками качества фильтрации импульсного шума на изображении на основе пикового отношения сигнала к шуму и индекса структурного сходства. Предлагаемый метод может найти применение в задачах очистки изображений в условиях искажающего импульсного воздействия и для устранения искажений от неблагоприятных погодных эффектов, таких как капли дождя и снег.
Заключение:
В работе предложен метод обнаружения и очистки изображений от случайнозначного импульсного шума. Результаты моделирования продемонстрировали преимущество предлагаемого метода на основе характеристик PSNR и SSIM. Преимущество особенно ярко выражено для высокой интенсивности шума. Также визуальный анализ представленных фрагментов тестовых изображений позволяет сделать вывод о том, что предложенный метод не только хорошо справляется с задачей, но и обнаруживает большее количество искаженных пикселей.
Дальнейшим направлением исследований может быть применение предложенного метода для удаления негативного влияния погодных эффектов, таких как дождь и снег, с изображений или видео, а также при проектировании каналов передачи изображений и видео без кодирования.
Анализ работы:
Статья описывает методику, основанную на детектировании и устранении импульсного шума с помощью адаптивного медианного фильтра. В предложенном методе вводится понятие сходства между пикселями, которое определяется как функция расстояния и разницы в яркости в локальном окне детектора. Модель импульсного шума предполагает, что искаженные пиксели случайным образом принимают значения, а также появляются случайным образом на изображении. После обнаружения искаженных пикселей, они восстанавливаются с помощью медианного фильтра. Этот метод может быть полезен для нашего исследования, так как методы, основанные на детектировании и устранении импульсного шума, являются ключевыми при очистке изображений от ненужной информации, которая может искажать визуальные данные.
11. Новые методы адаптивной медианной фильтрации импульсного шума в изображениях¶
Аннотация:
В статье предложены два новых метода адаптивной медианной фильтрации импульсного шума в изображениях. Первый метод основан на совместном применении итеративной обработки и преобразования результата медианной фильтрации на основе распределения Лоренца. Второй метод использует альтернативные маски медианного фильтра, рассчитанные с использованием метрики Евклида. Такой подход позволил уменьшить размер обрабатываемой области без потери качества обработки для шумов с низкой интенсивностью. В экспериментальной части статьи приведены результаты сравнения качества работы предложенных методов с известными. Для моделирования были использованы 3 различных изображения, искаженные импульсным шумом с вероятностями искажения пикселей от 1 % до 99 % включительно. Численная оценка качества очистки изображений от шума на основе пикового отношения сигнала к шуму (PSNR) и индекса структурного сходства (SSIM) показала, что предложенные методы показывают лучший результат обработки во всех рассмотренных случаях по сравнению с известными подходами. Полученные в статье результаты могут найти широкое практическое применение в обработке спутниковых и медицинских изображений, геофизических данных и других приложениях цифровой обработки изображений.
Заключение:
В работе предложены два новых метода очистки изображений от импульсного шума, которые позволяют улучшить качество обработки по сравнению с известными подходами. Численная оценка результатов моделирования на основе PSNR и SSIM позволяет сделать вывод о том, что разработанные методы лучше справляются как с очисткой от шумов с низкой интенсивностью, так и с очисткой от экстремальных шумов с интенсивностью 90 – 99 %. Визуальное сопоставление результатов обработки позволяет сделать вывод о том, что предложенные методы не только хорошо справляются с восстановлением искаженных пикселей, но и позволяют сохранить детали изображения. Полученный результат позволяет решать проблему очистки от импульсного шума с более высокой эффективностью.
Интересным направлением дальнейших исследований является применение предложенных методов в практических приложениях цифровой обработки изображений, например, для обработки визуальных данных в медицинской диагностике.
Анализ работы:
Статья представляет два улучшенных подхода к медианной фильтрации для устранения импульсного шума. Первый метод использует итеративную обработку и преобразование результата медианной фильтрации с учетом распределения Лоренца. Второй метод основывается на альтернативных масках медианного фильтра, рассчитанных с использованием метрики Евклида. Этот подход позволяет уменьшить размер обрабатываемой области без потери качества для шумов с низкой интенсивностью. В статье также приведены экспериментальные результаты, сравнивающие предложенные методы с существующими. Эти методы могут быть полезны для нашего исследования, так как они позволяют эффективно устранять шумы в изображениях, что является важным этапом в процессе очистки данных с помощью OpenCV.
12. Применение генетического алгоритма для очистки цифрового изображения от коррелированного шума¶
Аннотация:
При использовании изображений для выполнения прикладных исследований нередко сталкиваются с наличием шумов, содержащихся на изображении. Для устранения шумов разработаны и широко применяются методы частотной фильтрации. Однако на спектре изображения не всегда удается разделить частоты, соответствующие шуму, и частоты, соответствующие изображению. В том случае, когда шум, содержащийся в изображении, обладает свойством пространственной коррелированности, возможно применение генетического алгоритма для получения случайного поля, взаимно коррелированного с содержащимся на изображении шумом, и последующая очистка изображения от шума. В статье рассмотрено применение генетического алгоритма для получения взаимно коррелированного случайного поля, это позволит выполнить очистку изображения от шума, повысив тем самым его качество. На примере конкретного изображения показано, что рассмотренный алгоритм имеет преимущество в сравнении с частотной фильтрацией. В качестве критериев оценки меры близости приведены взаимные корреляционные функции модельного шума и случайного поля, полученного в результате работы предлагаемого генетического алгоритма, а также взаимные корреляционные функции модельного незашумленного изображения и изображения, полученного в результате очистки.
Заключение:
В статье рассмотрено применение генетического алгоритма генерирования взаимно- коррелированных случайных полей для очистки цифрового изображения от коррелированного шума. Несмотря на то, что в статье приведен лишь один пример, проведена серия экспериментов с различными комбинациями частот в шуме. В большинстве из них применение генетического алгоритма для получения коррелированного шума показало преимущество перед частотной фильтрацией.
Анализ работы:
Статья предлагает методику удаления шума с использованием генетических алгоритмов. В случае, когда шум на изображении имеет пространственную коррелированность, традиционные методы частотной фильтрации не всегда эффективны, так как они не могут разделить частоты, соответствующие шуму и изображению. В данной работе предложен подход, при котором генетический алгоритм используется для создания случайного поля, коррелированного с шумом, и далее применяется для очистки изображения. Этот метод может быть полезен в нашем контексте, так как генетические алгоритмы позволяют эффективно справляться с шумами, которые трудно устранить с помощью стандартных методов фильтрации, таких как медианная или Винеровская фильтрация.
13. Improved SRGAN for Remote Sensing Image Super-Resolution Across Locations and Sensors¶
Работа, переведенная при помощи Google Translate: Открыть
Ссылка на источник: https://www.mdpi.com/2072-4292/12/8/1263
Аннотация:
Детальная и точная информация о пространственном распределении земного покрова и землепользования является важным компонентом местной экологии и экологических исследований. Для выполнения таких задач требуются изображения с высокой пространственной разрешающей способностью. Учитывая компромисс между высокой пространственной и высокой временной разрешающей способностью в спутниковых снимках, были разработаны различные обучающие модели (например, сверточные нейронные сети, разреженное кодирование, байесовские сети), направленные на улучшение пространственной разрешающей способности низкокачественных изображений как в области компьютерного зрения, так и в области дистанционного зондирования Земли. Однако данные для обучения и тестирования в этих методах часто ограничены определенной локацией и конкретным датчиком, что снижает способность модели к обобщению на другие локации и датчики.
Недавно генеративные состязательные сети (GAN), новая модель обучения из области глубокого обучения, показали свои преимущества в захвате высокоразмерных нелинейных признаков на больших выборках. В данном исследовании проверяется, может ли метод GAN улучшить способность к обобщению для разных локаций и датчиков с некоторыми изменениями, чтобы реализовать идею «обучение один раз, применение везде и для различных датчиков» для изображений дистанционного зондирования. Эта работа основывается на супер-разрешающих генеративных состязательных сетях (SRGAN), в которых изменены функция потерь и структура сети SRGAN. Предлагается улучшенная версия SRGAN (ISRGAN), которая делает обучение модели более стабильным и улучшает способность к обобщению для разных локаций и датчиков.
В эксперименте данные для обучения и тестирования были собраны с двух датчиков (Landsat 8 OLI и китайский GF 1) в различных локациях (Гуандун и Синьцзян в Китае). Для теста на кросс-локации модель обучалась на данных китайского GF 1 (8 м) в Гуандуне и тестировалась на данных GF 1 в Синьцзяне. Для теста на кросс-датчиках модель, обученная в Гуандуне на данных GF 1, тестировалась на изображениях Landsat 8 OLI в Синьцзяне. Предложенный метод был сравнён с методами соседнего встраивания (NE), разреженного представления (SCSR) и SRGAN. Для количественной оценки использовались показатели отношения сигнал/шум (PSNR) и структурного сходства (SSIM). Результаты показали, что ISRGAN превосходит методы NE (PSNR: 30.999, SSIM: 0.944) и SCSR (PSNR: 29.423, SSIM: 0.876), а также SRGAN (PSNR: 31.378, SSIM: 0.952), достигнув PSNR = 35.816 и SSIM = 0.988 в тесте на кросс-локации. Подобные результаты были получены и в тесте на кросс-датчиках. ISRGAN показал лучший результат (PSNR: 38.092, SSIM: 0.988) по сравнению с NE (PSNR: 35.000, SSIM: 0.982), SCSR (PSNR: 33.639, SSIM: 0.965) и SRGAN (PSNR: 32.820, SSIM: 0.949).
Кроме того, был протестирован прирост точности классификации земного покрова до и после супер-разрешения с использованием ISRGAN. Результаты показали, что точность классификации земного покрова после супер-разрешения значительно улучшилась, особенно для класса непроницаемой поверхности (дороги и здания с текстурами высокого разрешения), который улучшился на 15%.
Заключение:
Основываясь на алгоритме супер-разрешения генеративной состязательной сети в области компьютерного зрения, данная статья ставит своей целью решение проблем исчезновения градиентов и коллапса режимов, которые возникают при обучении самих генеративных состязательных сетей. В сочетании с методом минимизации расстояния Вассерштейна, предложенным в WGAN, мы модифицировали исходную сеть супер-разрешения (SRGAN) и предложили ISRGAN. Затем мы применили её для супер-разрешения спутниковых изображений и сделали следующие выводы:
Сеть супер-разрешения ISRGAN, предложенная в данной статье, была применена к задаче супер-разрешения спутниковых изображений, и полученные результаты оказались лучше, чем у других методов супер-разрешения, таких как метод соседнего встраивания, метод разреженного представления и SRGAN;
Для реализации одноразового обучения и многократного использования модели супер-разрешения мы напрямую применили модель, обученную на данных изображений GF 1 из Гуандуна, к данным изображений GF 1 из Синьцзяна, а затем провели t-тест для оценки результатов супер-разрешения на двух наборах данных. Это подтвердило способность модели к обобщению для различных локаций;
С целью объединить преимущества данных изображений GF 1 и Landsat 8, модель супер-разрешения, обученную на данных GF 1, была непосредственно применена к данным Landsat 8. Затем был проведён t-тест для оценки результатов супер-разрешения, что подтвердило способность модели к обобщению для различных датчиков;
В качестве примеров мы взяли классификацию землепользования и извлечение объектов на местности. Мы сравнили точность классификации и извлечения объектов до и после супер-разрешения. Для классификации землепользования использовался алгоритм K-средних, а для извлечения объектов — алгоритм SVM. Результаты показали, что визуальные эффекты и точность изображений после супер-разрешения улучшились как в классификации, так и в извлечении объектов, что свидетельствует о значительном приложении супер-разрешения спутниковых изображений в таких областях, как разработка ресурсов, мониторинг окружающей среды, исследование катастроф и анализ глобальных изменений.
Анализ работы:
Статья описывает улучшенную версию SRGAN для повышения разрешающей способности спутниковых и удаленных сенсорных изображений. Авторы предлагают метод, который улучшает качество изображений с использованием генеративных состязательных сетей, адаптированных к различным локациям и сенсорам. Это важное достижение для анализа земных покровов и использования земных ресурсов, а также для улучшения пространственного разрешения спутниковых данных.
Хотя эта работа сосредоточена на улучшении пространственного разрешения изображений, с помощью SRGAN, она также подчеркивает использование сложных методов очистки изображений. Это может быть полезно для нашего исследования, так как методы улучшения разрешения могут дополнить стандартные подходы очистки.
14. StarSRGAN Improving Real-World Blind Super-Resolution¶
Открыть работу StarSRGAN_Improving_Real-World_Blind_Super-Resolution.pdf
Работа, переведенная при помощи Google Translate: Открыть
Ссылка на источник: https://arxiv.org/abs/2307.16169
Аннотация:
Цель слепого супер-разрешения (SR) в области компьютерного зрения — улучшить разрешение изображения без предварительных данных о процессе деградации, который привёл к понижению разрешающей способности изображения. Современная модель (State of the Art, SOTA) Real-ESRGAN использует улучшенную перцептивную потерю и генерирует визуально впечатляющие результаты, применяя более сложные модели деградации для симуляции реальных искажений. Тем не менее, существует ещё потенциал для улучшения качества супер-разрешения Real-ESRGAN с использованием новых технологий.
В данной исследовательской работе представлена StarSRGAN — новая модель GAN, разработанная для задач слепого супер-разрешения, использующая 5 различных архитектур. Наша модель демонстрирует новые результаты уровня SOTA, обеспечивая примерно на 10% лучшие показатели по метрам MANIQA и AHIQ по сравнению с Real-ESRGAN. Кроме того, компактная версия модели StarSRGAN Lite обеспечивает примерно в 7,5 раз более быструю скорость реконструкции (реальное время увеличения разрешения с 540p до 4K), сохраняя при этом почти 90% качества изображения. Это способствует созданию опыта реального времени для супер-разрешения в будущих исследованиях.
Код модели доступен по ссылке: https://github.com/kynthesis/StarSRGAN.
Заключение:
Настоящее исследование представляет два новых GAN-основанных модели — StarSRGAN и StarSRGAN Lite — для задач слепого супер-разрешения (SR). StarSRGAN интегрирует достижения из 5 предыдущих исследований и демонстрирует новые результаты уровня SOTA, превосходя ведущий метод супер-разрешения, Real-ESRGAN, на 10% по методам оценки качества без ссылок (SOTA No-Reference IQA) и с полной ссылкой (Full-Reference IQA), таким как MANIQA и AHIQ. StarSRGAN Lite, облегчённая версия StarSRGAN, также наследует улучшения от предшественника и предлагает производительность реального времени, обрабатывая увеличенные кадры с 540p до 4K со скоростью более 20 кадров в секунду при выполнении на оптимизированном C++ исполняемом файле.
В статье также предлагаются несколько направлений для дальнейшего улучшения архитектур StarSRGAN. Например, переобучение моделей на недавно выпущенных датасетах, таких как DIV8K или Unsplash. Также использование других активационных функций, таких как SiLU и GELU, может стать лучшей альтернативой привычному ReLU. Повышение производительности StarSRGAN может быть достигнуто с помощью супер-разрешения только для интересующих объектов и игнорирования ненужных областей, таких как фон. Применение техник Video SR и использование пространственно-временных данных также могут стать перспективным направлением для дальнейших исследований.
В настоящий момент модели StarSRGAN поддерживают только коэффициент увеличения 4×, однако необходимо добавить и другие коэффициенты увеличения, такие как 2×, 8× и 16×. Другим подходом является использование классификатора изображений для различения реальных и нереальных изображений и выбора наиболее оптимизированных для каждого случая. Также можно исследовать более подходящий размер пакета и большее количество итераций с использованием более мощного оборудования.
В заключение, предложенные направления могут способствовать развитию будущих исследований в этой области.
Анализ работы:
Статья описывает метод для улучшения разрешения изображений, не имея предварительной информации о процессе деградации, который привел к снижению качества изображения. Основное внимание уделяется так называемой слепой супер-разрешимости (blind super-resolution), где не требуется знание точных характеристик деградации изображения. Модель Real-ESRGAN, одна из самых современных, использует улучшенные функции потерь для восприятия и создает визуально привлекательные результаты, имитируя реальные модели деградации. В статье также предложены улучшения модели для повышения качества супер-разрешенных изображений.
Этот метод может быть полезен в нашем исследовании. Модели супер-разрешимости, такие как StarSRGAN, могут значительно улучшить качество изображений, что является полезным дополнением к методам очистки и обработки данных.
15. Old Document Restoration using Super Resolution GAN and Semantic Image Inpainting¶
Работа, переведенная при помощи Google Translate: Открыть
Ссылка на источник: https://dl.acm.org/doi/abs/10.1145/3397453.3397459
Аннотация:
Восстановление повреждённых изображений — это основная задача, которая ставилась ещё до появления технологий цифровой обработки изображений. В этой статье мы предлагаем сеть для восстановления изображений, использующую технологию генеративных состязательных сетей (GAN). Предложенная система представляет собой сеть для генерации изображений, результат генерации которой основан на звёздной сети. Старые документы не только содержат информацию, но также позволяют узнать о мыслях и сознании исторических людей. Восстановление старых документов относится к процессу восстановления документов, обычно выполненных на пергаменте, которые были повреждены как естественным, так и искусственным путём. Пропавшие области старых документов восстанавливаются на основе имеющихся визуальных данных, что представляет собой сложную задачу в области воссоздания изображений.
В этой работе мы представляем Generative Adversarial Network для супер-разрешения (SRGAN) и семантическое воссоздание изображений, применяемые для восстановления старых документов, чтобы их можно было использовать повторно.
Заключение:
В этой статье мы предлагаем метод реконструкции изображения с использованием контекстной информации окружающих изображений, применяя глубокую нейронную сеть и генеративную состязательную сеть. Также при реконструкции этих изображений мы предложили метод, который позволяет восстанавливать более реалистичное изображение, восстанавливая детали изображения и текстуру одновременно с естественным восстановлением, регулируя переменные значения алгоритма.
Мы протестировали процесс супер-разрешения с использованием генеративной состязательной сети и семантическое воссоздание изображений на 3500 старых документах и получили очень хорошие результаты, практически точные во всех случаях.
В будущем мы планируем расширить эту работу, чтобы улучшить процесс восстановления и повысить точность восстановления повреждённых документов, а также извлечь каждый текст из восстановленного изображения отдельно для полного завершения процесса восстановления.
Анализ работы:
Статья посвящена восстановлению поврежденных изображений с помощью технологий глубокого обучения, в частности, с использованием генеративных состязательных сетей (GAN). Авторы предлагают систему для восстановления старых документов, использующую супер-разрешение и семантическую вкрапление изображения. Эта методика включает в себя улучшение качества изображений, восстановление утраченных частей и детализацию поврежденных участков.
Этот метод может быть полезен в нашем исследовании. Использование GAN для восстановления изображений может улучшить качество обработки данных и добавить дополнительные возможности для восстановления информации.
16. DE-GAN A Conditional Generative Adversarial Network for Document Enhancement¶
Работа, переведенная при помощи Google Translate: Открыть
Ссылка на источник: https://ieeexplore.ieee.org/abstract/document/9187695
Аннотация:
Автоматическая обработка документов заключается в преобразовании документа в форму, понятную как системе компьютерного зрения, так и человеку. Благодаря развитию нескольких общедоступных баз данных, обработка документов достигла значительного прогресса в последние годы [1], [2]. Однако эта обработка не всегда эффективна, когда документы повреждены. На бумажный документ могут быть нанесены различные повреждения. Например: складки, пыль, пятна от кофе или пищи, выцветшие солнечные пятна и многие другие реальные сценарии [3]. Деградация также может проявляться в отсканированных документах из-за плохих условий оцифровки, таких как использование камер смартфонов (тени [4], размытие [5], изменение условий освещенности, искажения и т.д.). Более того, некоторые документы могут содержать водяные знаки, штампы или аннотации. Восстановление становится еще более сложным, когда некоторые из этих объектов закрывают текст, например, в случаях, когда цвет пятен совпадает с цветом шрифта документа или темнее его (рис. 1 показывает несколько примеров). Таким образом, необходим подход для восстановления чистой версии поврежденного документа.
В данном исследовании мы сосредотачиваемся на двух проблемах улучшения качества документов: восстановление поврежденных документов, т.е. создание чистой (градационная или бинарная) версии документа при любом типе деградации, и удаление водяных знаков. Основные трудности следующие: наложение шума или водяных знаков на текст, плотные водяные знаки, интенсивные загрязнения или деградация, которые могут полностью закрыть текст, что делает его чтение крайне затруднительным. Также нет предварительной информации о характере деградации или водяного знака, который нужно удалить. Идеальная система должна эффективно выполнять две задачи одновременно: удалять шум и водяные знаки, а также сохранять качество текста в изображениях документов.
Недавние успехи в области глубоких нейронных сетей, особенно глубоких сверточных нейронных сетей (автокодировщики и вариационные автокодировщики (VAE)) [6], [7], [8] и генеративных состязательных сетей (GAN) [9], [10], позволили добиться значительных результатов в генерации и восстановлении изображений. GAN, которые были введены в [11], теперь считаются идеальным решением для проблем генерации изображений с высоким качеством, стабильностью и разнообразием по сравнению с автокодировщиками. Генеративные модели привлекли больше внимания благодаря способности захватывать многомерные распределения вероятностей, восполнять недостающие данные и работать с многомодальными выходами. Тем не менее, сообщество исследований анализа документов ещё недостаточно использует эти подходы. Их применение ограничено, например, в переводе шрифтов [12], профилировании рукописных текстов [13] и удалении линий staff из изображений музыкальных партитур [14], где были получены многообещающие результаты.
В [9] Исолла и соавт. показали, что условные генеративные состязательные сети (cGAN), разновидность GAN, хорошо справляются с задачей перевода изображений (например, с метками на фасад, день на ночь, края на фото, ч/б на цветное изображение и т.д.). В то время как GAN обучают генеративную модель данных, условные GAN (cGAN) обучаются на условной генеративной модели, где условием является входное изображение, а выходом — соответствующее ему изображение. Поскольку улучшение качества документов следует аналогичному процессу, т.е. мы хотим сохранить текст и удалить повреждения в условном изображении, cGAN является подходящим решением для этой задачи, что и стало мотивацией для данного исследования.
Основные вкладки этой работы следующие:
Во-первых, насколько нам известно, это первое использование GAN, а именно условных GAN, в рамках решения различных проблем улучшения качества документов (очистка, бинаризация и удаление водяных знаков). Во-вторых, мы использовали простую, но гибкую архитектуру, которая может быть адаптирована для решения любых проблем деградации документов. В-третьих, мы вводим новую проблему улучшения качества документов, связанную с удалением плотных водяных знаков и штампов. В-четвертых, мы экспериментально доказали, что наш подход достигает более высокой производительности по сравнению с методами, являющимися состоянием искусства, в задачах бинаризации поврежденных документов. Остальная часть статьи организована следующим образом. В разделе 2 представлен обзор предыдущих работ по улучшению качества документов, особенно по очистке, бинаризации и удалению водяных знаков как в документах, так и в естественных изображениях. Также рассматриваются некоторые связанные работы с использованием GAN в задачах перевода изображений. Затем в разделе 3 представлена наша предложенная методика. В разделе 4 описаны экспериментальные результаты и сравнение с традиционными и современными методами. Наконец, в разделе 5 сделаны выводы и предложены направления для дальнейших исследований.
Заключение:
В этой статье мы предлагаем Generative Adversarial Network для улучшения качества документов, названную DE-GAN, предназначенную для восстановления сильно повреждённых изображений документов. DE-GAN является модифицированной версией pix2pix, с более глубокой генераторной сетью и другим дополнительным функционалом потерь (состязательные + логарифмические потери), чтобы генерировать улучшенную версию документа на основе его повреждённой версии. Насколько нам известно, это первое применение GAN для исследования проблемы улучшения качества документов. Кроме того, мы представляем новую задачу в улучшении качества документов — удаление плотных водяных знаков (или штампов), надеясь, что это привлечёт внимание сообщества анализа документов.
Обширные эксперименты показывают, что DE-GAN достиг интересных результатов в различных задачах улучшения качества документов, превосходящих такие модели, как fully convolutional networks, cycleGAN и pix2pix-HD. Более того, мы получили улучшенные результаты по сравнению с многими современными методами на стандартных тестовых наборах, таких как DIBCO 2013, DIBCO 2017 и HDIBCO 2018.
Мы продемонстрировали, что предложенный метод улучшения значительно повышает начальную производительность OCR. Таким образом, в качестве следующего шага в нашем исследовании, мы планируем добавить оценку OCR в часть дискриминатора. Это позволит дискриминатору "читать" текст, чтобы определить, является ли изображение реальным или фальшивым, что побудит модель генерировать более читаемые изображения. Мы также намерены протестировать производительность DE-GAN на документах, снятых с мобильных устройств, которые часто сталкиваются с такими проблемами, как тени, реальные размытия, низкое разрешение, искажения и т.д.
Анализ работы:
Статья представляет метод DE-GAN, основанный на условных генеративных состязательных сетях (cGAN), для улучшения качества документов. Эта модель предназначена для восстановления сильно деградированных изображений документов, улучшая их читаемость и производительность системы оптического распознавания символов (OCR). Основной акцент в работе сделан на восстановлении информации, улучшении визуального качества и удалении помех.
Этот метод может быть особенно полезен в нашем исследовании. Использование cGAN в DE-GAN позволяет эффективно восстанавливать информацию, что может быть полезно для очистки изображений с сохранением важных данных.
17. SRR-GAN Super-Resolution based Recognition with GAN for Low-Resolved Text Images¶
Работа, переведенная при помощи Google Translate: Открыть
Ссылка на источник: https://ieeexplore.ieee.org/abstract/document/9257746
Аннотация:
Текстовые изображения передают важную информацию для различных приложений, однако распознавание текстов с низким разрешением остаётся сложной задачей. Большинство существующих методов решают эту проблему с помощью каскадной схемы, состоящей из двух этапов: супер-разрешение изображения и распознавание текста с высоким разрешением. В этой статье мы предлагаем новую концепцию под названием SRR-GAN, которая интегрирует распознавание текста с супер-разрешением с помощью состязательного обучения.
Путём совместного обучения моделей распознавания и супер-разрешения, можно извлечь более универсальные признаки для изображений различного качества, что позволяет достичь высокой производительности распознавания как для изображений с высоким, так и с низким разрешением. Эксперименты на изображениях с текстами на природных сценах и рукописных текстах показывают, что SRR-GAN превосходит каскадную схему на изображениях с низким разрешением. Результаты показывают, что SRR-GAN может улучшить точность распознавания на 10%-20% относительно пяти наборов данных с текстами на сценах/рукописях. При этом SRR-GAN сохраняет высокую производительность на изображениях с высоким разрешением.
Заключение:
В этой статье мы представляем новую концепцию, называемую SRR-GAN, для совместного обучения супер-разрешения и модели распознавания для распознавания текста с низким разрешением. В отличие от каскадной схемы, где модели супер-разрешения и распознавания обучаются независимо, предложенный метод позволяет получить восстановленное изображение с супер-разрешением, которое лучше подходит для распознавания. Экспериментальные результаты на задачах распознавания текста на сценах и рукописного текста на общедоступных наборах данных показывают, что предложенный метод превосходит другие подходы при работе с изображениями текста с низким разрешением.
Анализ работы:
Статья рассматривает метод улучшения разрешения и распознавания текста на изображениях с низким разрешением с использованием генеративных состязательных сетей (GAN). Авторы предлагают новую структуру под названием SRR-GAN, которая интегрирует два этапа: улучшение разрешения изображения (супер-разрешение) и распознавание текста. Этот подход решает задачу улучшения качества текстовых изображений с низким разрешением, что является важным для эффективного извлечения информации из таких изображений.
Этот метод может быть полезен для нашего исследования, так как он сочетает улучшение качества изображений с распознаванием информации, что может быть важным. Использование GAN в таких контекстах может помочь улучшить визуальное качество и точность восстановления изображений, что полезно для очистки.
18. Exploiting Diffusion Prior for Real-World Image Super-Resolution¶
Работа, переведенная при помощи Google Translate: Открыть
Ссылка на источник: https://arxiv.org/abs/2305.07015
Аннотация:
Разлагая процесс формирования изображения на последовательное применение денойзинговых автоэнкодеров, диффузионные модели (DM) достигают выдающихся результатов в синтезе изображений и за их пределами. Кроме того, их формулировка позволяет внедрить механизм управления процессом генерации изображения без необходимости переобучения. Однако, поскольку эти модели обычно работают непосредственно в пиксельном пространстве, оптимизация мощных диффузионных моделей часто требует сотен дней работы на GPU, а вывод (инференс) оказывается дорогим из-за последовательных вычислений.
Для того чтобы обеспечить обучение диффузионных моделей при ограниченных вычислительных ресурсах, сохраняя их качество и гибкость, мы применяем их в латентном пространстве мощных предварительно обученных автоэнкодеров. В отличие от предыдущих работ, обучение диффузионных моделей на таком представлении позволяет впервые достичь почти оптимального баланса между снижением сложности и сохранением деталей, значительно улучшая визуальную точность.
Внедрив слои кросс-внимания в архитектуру модели, мы превращаем диффузионные модели в мощные и гибкие генераторы для общих входных данных, таких как текст или ограничивающие прямоугольники, а высококачественный синтез становится возможным в сверткиваемом (конволюционном) формате. Наши латентные диффузионные модели (LDM) устанавливают новые достижения в области восстановления изображений и синтеза изображений с условием по классу, а также демонстрируют высококонкурентоспособные результаты по различным задачам, включая синтез изображений из текста, генерацию изображений без условий и суперразрешение, при этом значительно снижая вычислительные затраты по сравнению с диффузионными моделями, работающими в пиксельном пространстве.
Заключение:
Мы представили латентные диффузионные модели — простой и эффективный способ значительно улучшить как эффективность обучения, так и эффективность выборки (sampling) диффузионных моделей денойзинга, не ухудшая их качество. Основываясь на этом и нашем механизме условной генерации с использованием кросс-внимания, наши эксперименты показали хорошие результаты по сравнению с передовыми методами на широком спектре задач синтеза изображений с условием, без необходимости использования специфических для задач архитектур.
Анализ работы:
Статья рассматривает использование моделей латентного диффузии (LDM) для синтеза изображений с высоким разрешением. Модели диффузии, использующие последовательное приложение автоэнкодеров для удаления шума, показывают выдающиеся результаты в синтезе изображений и других данных. Однако, традиционные модели диффузии работают в пространстве пикселей, что требует значительных вычислительных ресурсов и времени на обучение, а также делает вывод модели затратным.
Методы, предложенные в статье, позволяют значительно улучшить качество изображений, что может быть полезно в контексте восстановления изображений с низким разрешением. Этот подход может дополнить наш инструмент очистки, улучшив детали изображений с помощью моделей, которые эффективно генерируют высококачественные изображения даже с ограниченными ресурсами.
19. High-Resolution Image Synthesis with Latent Diffusion Models¶
Работа, переведенная при помощи Google Translate: Открыть
Ссылка на источник: https://arxiv.org/abs/2112.10752
Аннотация:
Мы представляем новый подход, который использует предварительные знания, заключенные в предварительно обученных моделях диффузии для синтеза изображений из текста, для слепого суперразрешения (SR). Конкретно, с помощью нашего временно-осведомленного энкодера мы можем достичь многообещающих результатов восстановления без изменений в предварительно обученной модели синтеза, тем самым сохраняя генеративный приоритет и минимизируя затраты на обучение. Чтобы устранить потерю точности, вызванную врожденной стохастичностью диффузионных моделей, мы используем управляемый модуль оборачивания признаков, который позволяет пользователям балансировать качество и точность, просто регулируя скалярное значение в процессе инференса. Более того, мы разрабатываем стратегию прогрессивной агрегации выборки, чтобы преодолеть ограничения фиксированного размера предварительно обученных диффузионных моделей, позволяя адаптироваться к разрешениям любого размера. Всесторонняя оценка нашего метода с использованием как синтетических, так и реальных бенчмарков демонстрирует его превосходство над текущими передовыми подходами. Код и модели доступны по адресу: https://github.com/IceClear/StableSR.
Заключение:
Вдохновленные быстрым развитием диффузионных моделей и их широким применением в downstream-задачах, в данной работе обсуждается важная, но недостаточно исследованная проблема того, как можно использовать диффузионный приоритет для суперразрешения. В этой статье мы представляем StableSR — новый способ использования диффузионного приоритета для суперразрешения в реальных условиях, при этом избегая затратного обучения с нуля. Мы сосредоточили наши усилия на решении хорошо известных проблем, таких как высокие вычислительные затраты и фиксированное разрешение, и предлагаем соответствующие решения, включая временно-осведомленный энкодер, управляемый модуль оборачивания признаков и схему прогрессивной агрегации выборки. Проведены обширные эксперименты для оценки, а также предоставлены эффективные стратегии инференса для упрощения практических приложений. Мы уверены, что наше исследование закладывает хорошую основу в этом направлении, и предлагаемая нами модель StableSR может предоставить полезные идеи для будущих работ.
Признание: Это исследование поддерживается Национальным фондом исследований Сингапура в рамках программы AI Singapore (AISG Award No: AISG2-PhD-2022-01-033[T]), инициативой RIE2020 Industry Alignment Fund Industry Collaboration Projects (IAF-ICP), а также денежными и неденежными вкладом от промышленного партнера(ов). Мы искренне благодарим Ии Ли за предоставленные ценные советы и создание WebUI-реализации нашей работы. Мы также благодарим сообщество за постоянный интерес и вклад.
Анализ работы:
Статья описывает новый подход, использующий предварительно обученные текстово-изображенные диффузионные модели для слепой супер-разрешимости изображений (blind SR). Метод позволяет восстанавливать изображения, используя знания, заложенные в этих моделях, без необходимости изменения самой модели генерации, что помогает сохранить её приоритет и минимизировать затраты на обучение. Для устранения потери точности, вызванной случайностью диффузионных моделей, авторы предлагают модуль контролируемой обертки признаков, который позволяет пользователю регулировать баланс качества и точности в процессе вывода, изменяя лишь один параметр.
Этот подход может быть полезен в нашем исследовании. Использование диффузионных моделей для улучшения изображений может быть полезным инструментом для вашего инструмента очистки изображений, особенно при необходимости сохранить детали и качества изображений в реальных условиях.
20. Real-ESRGAN: Training Real-World Blind Super-Resolution with Pure Synthetic Data¶
Работа, переведенная при помощи Google Translate: Открыть
Ссылка на источник: https://arxiv.org/abs/2107.10833
Аннотация:
Несмотря на множество попыток в области слепой суперразрешающей обработки для восстановления изображений низкого разрешения с неизвестными и сложными искажениями, они всё ещё далеки от решения проблемы обработки изображений с реальными искажениями. В данной работе мы расширяем мощный ESRGAN для практического применения восстановления изображений (а именно, Real-ESRGAN), который обучается на чисто синтетических данных. Конкретно, вводится процесс моделирования высокоуровневых искажений для лучшего симулирования сложных реальных искажений. Мы также учитываем общие артефакты, такие как рингинг и перерасходы, в процессе синтеза. Кроме того, мы используем дискриминатор на основе U-Net с спектральной нормализацией, чтобы повысить его способность и стабилизировать динамику обучения. Обширные сравнения показали его превосходные визуальные результаты по сравнению с предыдущими работами на различных реальных датасетах. Мы также предоставляем эффективные реализации для синтеза пар данных в процессе обучения в реальном времени.
Заключение:
В данной работе мы обучаем практическую модель Real-ESRGAN для слепого суперразрешения изображений в реальных условиях, используя исключительно синтетические пары для обучения. Для синтеза более реалистичных искажений мы предлагаем процесс высокоуровневого моделирования и используем фильтры синуса (sinc) для моделирования общих артефактов, таких как рингинг и перерасход. Также мы применяем дискриминатор на основе U-Net с регуляризацией спектральной нормализацией, чтобы повысить его способность и стабилизировать динамику обучения. Real-ESRGAN, обученная на синтетических данных, способна улучшать детали изображений, одновременно устраняя надоедливые артефакты для большинства реальных изображений.
Анализ работы:
Статья описывает метод Real-ESRGAN, который расширяет возможности ESRGAN (Enhanced Super-Resolution Generative Adversarial Network) для решения задачи восстановления изображений с низким разрешением. В отличие от предыдущих методов, Real-ESRGAN обучается исключительно на синтетических данных, что позволяет более эффективно моделировать реальные деформации изображений. Ключевой особенностью является внедрение сложной модели деградации, что помогает имитировать различные реальные искажений. Также используется U-Net дискриминатор с спектральной нормализацией для улучшения качества генерации и стабилизации процесса обучения. Этот подход показал лучшие результаты по сравнению с предыдущими методами, устраняя артефакты и улучшая детали на реальных изображениях.
21. Plug-and-Play Image Restoration with Deep Denoiser Prior¶
Открыть работу Plug-and-Play_Image_Restoration_with_Deep_Denoiser_Prior.pdf
Работа, переведенная при помощи Google Translate: Открыть
Ссылка на источник: https://arxiv.org/abs/2008.13751v2
Аннотация:
Недавние работы по восстановлению изображений с использованием принципа plug-and-play показали, что денойзер может implicitly служить в качестве приоритета изображения для методов, основанных на моделях, для решения различных обратных задач. Такая особенность предоставляет значительные преимущества для восстановления изображений с использованием принципа plug-and-play (например, интеграция гибкости методов, основанных на моделях, и эффективности методов, основанных на обучении), когда денойзер обучается дискриминативно с помощью глубоких сверточных нейронных сетей (CNN) с большой модельной мощностью. Однако, несмотря на стремительное повышение популярности более глубоких и крупных моделей CNN, существующие методы восстановления изображений с использованием принципа plug-and-play ограничены в своей эффективности из-за недостатка подходящего приоритета от денойзера. Чтобы расширить возможности восстановления изображений с использованием принципа plug-and-play, мы создаем эталонный приоритет денойзера на основе глубоких сетей, обучая высокоэффективный и гибкий денойзер CNN. Затем мы интегрируем этот приоритет денойзера как модульную часть в итеративный алгоритм на основе половинного квадратичного разбиения для решения различных задач восстановления изображений. Мы также проводим тщательный анализ настройки параметров, промежуточных результатов и эмпирической сходимости, чтобы лучше понять рабочий механизм. Экспериментальные результаты по трем представительным задачам восстановления изображений, включая устранение размытости, сверхразрешение и демозаику, демонстрируют, что предложенное восстановление изображений с использованием принципа plug-and-play и глубокого приоритета денойзера не только значительно превосходит другие современные методы, основанные на моделях, но и достигает конкурентоспособных или даже более высоких результатов по сравнению с современными методами, основанными на обучении. Исходный код доступен по ссылке: https://github.com/cszn/DPIR.
Заключение:
В данной работе мы обучили гибкие и эффективные глубокие денойзеры для восстановления изображений с использованием принципа plug-and-play. Конкретно, используя алгоритм половинного квадратичного разбиения, итеративная оптимизация для трех различных задач восстановления изображений, включая устранение размытости, сверхразрешение и демозаику цветных изображений, заключается в чередующем решении подзадачи данных, для которой существует закрытое решение, и подзадачи приоритета, которую можно заменить глубоким денойзером. Мы провели обширные эксперименты и анализы по настройке параметров, промежуточным результатам и эмпирической сходимости. Результаты показали, что восстановление изображений с использованием принципа plug-and-play и мощного глубокого приоритета денойзера имеет несколько преимуществ. С одной стороны, оно повышает эффективность методов, основанных на моделях, благодаря неявному, но мощному моделированию приоритета глубоким денойзером. С другой стороны, без необходимости в обучении на конкретной задаче, оно более гибко, чем методы, основанные на обучении, при этом демонстрируя сопоставимую производительность. В заключение, эта работа подчеркивает преимущества восстановления изображений на основе глубокого денойзера с использованием принципа plug-and-play. Стоит отметить, что существует пространство для дальнейших исследований. Например, одним из направлений может быть интеграция других типов глубоких приоритетов изображений, таких как глубокий генеративный приоритет [97], для эффективного восстановления изображений.
Анализ работы:
Статья представляет метод DRUNet (Denoiser Residual U-Net), который является улучшенной версией классической архитектуры U-Net, специально адаптированной для восстановления изображений с использованием обученного денойзера. Этот метод интегрирует остаточное обучение в структуру U-Net, что позволяет эффективно восстанавливать детали изображения, устраняя при этом шум и артефакты. DRUNet показал отличные результаты в задачах супер-разрешения, восстановления после размытия и демозаикации, обеспечивая как высокое качество восстановления, так и точность в сохранении деталей. Метод хорошо подходит для задач, где необходимо работать с изображениями, подверженными различным искажениям, что делает его ценным для реальных приложений. Для нашей работы применение DRUNet позволит не только повысить качество восстановления изображений, но и сделать процесс устойчивым к реальным дефектам на изображениях, что обеспечит превосходные результаты в практических задачах.
Практическая часть. Реализация методов очистки информации на изображениях.¶
Инсталяция/импорт модулей и библиотек¶
!pip uninstall -y huggingface_hub
Found existing installation: huggingface-hub 0.10.1 Uninstalling huggingface-hub-0.10.1: Successfully uninstalled huggingface-hub-0.10.1
!pip install -q einops opencv-python-headless scikit-image pillow huggingface_hub==0.10.1
ERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts. accelerate 1.2.1 requires huggingface-hub>=0.21.0, but you have huggingface-hub 0.10.1 which is incompatible. diffusers 0.32.1 requires huggingface-hub>=0.23.2, but you have huggingface-hub 0.10.1 which is incompatible. peft 0.14.0 requires huggingface-hub>=0.25.0, but you have huggingface-hub 0.10.1 which is incompatible. sentence-transformers 3.3.1 requires huggingface-hub>=0.20.0, but you have huggingface-hub 0.10.1 which is incompatible. tokenizers 0.21.0 requires huggingface-hub<1.0,>=0.16.4, but you have huggingface-hub 0.10.1 which is incompatible. transformers 4.47.1 requires huggingface-hub<1.0,>=0.24.0, but you have huggingface-hub 0.10.1 which is incompatible.
# Системные и стандартные
import math
import os
import sys
# Работа с изображениями
import cv2
import numpy as np
from PIL import Image
from scipy.ndimage import gaussian_filter
# Анализ изображений
from skimage.metrics import structural_similarity as ssim
# PyTorch
import torch
from torchvision import transforms
# Google Colab
import gdown
from google.colab import files
from google.colab.patches import cv2_imshow
# Построение графиков
import matplotlib.pyplot as plt
from skimage import img_as_ubyte
import torch.nn as nn
import torch.nn.functional as F
Определение контролируемых параметров изображений¶
def test_image(img, shape_size=64, block_size=15, title='Результат обработки'):
"""
Функция для выделения горизонтальных и вертикальных линий на изображении
и объединения их в одно изображение.
:param img: Входное изображение (numpy.ndarray, цветное BGR).
:param shape_size: Масштаб размера ядра для выделения линий.
:param block_size: Размер блока для адаптивного порогового преобразования (должен быть нечётным).
:param title: Заголовок итогового графика.
"""
if img is None:
raise ValueError("Не удалось загрузить изображение. Проверьте файл.")
# Преобразование изображения в градации серого и инверсия
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
gray = cv2.bitwise_not(gray)
# Адаптивное пороговое преобразование
bw = cv2.adaptiveThreshold(
gray,
255,
cv2.ADAPTIVE_THRESH_MEAN_C,
cv2.THRESH_BINARY,
block_size,
-2
)
# Выделение горизонтальных линий
kernel_hor = np.ones((1, bw.shape[1] // shape_size), np.uint8)
horizontal = cv2.erode(bw, kernel_hor)
horizontal = cv2.dilate(horizontal, kernel_hor)
# Выделение вертикальных линий
kernel_vert = np.ones((bw.shape[0] // shape_size, 1), np.uint8)
vertical = cv2.erode(bw, kernel_vert)
vertical = cv2.dilate(vertical, kernel_vert)
# Объединение горизонтальных и вертикальных линий
combined_lines = cv2.bitwise_or(horizontal, vertical)
# Отображение только одного изображения "Захват вертикальных и горизонтальных линий"
plt.figure(figsize=(10, 10))
plt.imshow(combined_lines, cmap='gray')
plt.title('Захват вертикальных и горизонтальных линий')
plt.axis('off')
plt.suptitle(title)
plt.show()
def test_image_gray(gray_img, shape_size=64, block_size=15, title='Результат обработки'):
"""
Функция для выделения горизонтальных и вертикальных линий на сером изображении
и объединения их в одно изображение.
:param gray_img: Входное изображение в градациях серого (numpy.ndarray).
:param shape_size: Масштаб размера ядра для выделения линий.
:param block_size: Размер блока для адаптивного порогового преобразования (должен быть нечётным).
:param title: Заголовок итогового графика.
"""
if gray_img is None:
raise ValueError("Не удалось загрузить изображение. Проверьте файл.")
# Инвертирование изображения
gray_img = cv2.bitwise_not(gray_img)
# Адаптивное пороговое преобразование
bw = cv2.adaptiveThreshold(
gray_img,
255,
cv2.ADAPTIVE_THRESH_MEAN_C,
cv2.THRESH_BINARY,
block_size,
-2
)
# Выделение горизонтальных линий
kernel_hor = np.ones((1, bw.shape[1] // shape_size), np.uint8)
horizontal = cv2.erode(bw, kernel_hor)
horizontal = cv2.dilate(horizontal, kernel_hor)
# Выделение вертикальных линий
kernel_vert = np.ones((bw.shape[0] // shape_size, 1), np.uint8)
vertical = cv2.erode(bw, kernel_vert)
vertical = cv2.dilate(vertical, kernel_vert)
# Объединение горизонтальных и вертикальных линий
combined_lines = cv2.bitwise_or(horizontal, vertical)
# Отображение только одного изображения "Захват вертикальных и горизонтальных линий"
plt.figure(figsize=(10, 10))
plt.imshow(combined_lines, cmap='gray')
plt.title('Захват вертикальных и горизонтальных линий')
plt.axis('off') # Убираем оси
plt.suptitle(title)
plt.show()
Качество изображений будем контролировать параметрами PSNR и SSIM.
PSNR измеряет разницу между исходным и сжатым изображением, где более высокие значения указывают на лучшее качество.
SSIM оценивает схожесть между двумя изображениями, учитывая структуру, яркость и контраст, и дает более точное представление о восприятии качества человеком.
Расчет параметров взят с открытого репозитория https://github.com/cszn/DPIR/blob/master/utils/utils_image.py, который реализован в статье "Plug-and-Play Image Restoration with Deep Denoiser Prior"
gdown.download(f'https://raw.githubusercontent.com/cszn/DPIR/master/utils/utils_image.py', 'utils_image.py', quiet=False)
Downloading... From: https://raw.githubusercontent.com/cszn/DPIR/master/utils/utils_image.py To: /content/utils_image.py 26.0kB [00:00, 28.2MB/s]
'utils_image.py'
from utils_image import calculate_psnr, calculate_ssim
Загрузка и предобработка тестируемого изображения¶
Инициализация функций для обработки изображения¶
def resize_image_to_multiple_of_16(img):
# Получение текущих размеров
height, width = img.shape[:2]
# Вычисление новых размеров, кратных 16
new_height = height if height % 16 == 0 else height + (16 - height % 16)
new_width = width if width % 16 == 0 else width + (16 - width % 16)
# Изменение размера изображения
img_resized = cv2.resize(img, (new_width, new_height), interpolation=cv2.INTER_LINEAR)
return img_resized
def add_gaussian_noise(image, sigma):
"""
Добавляет гауссовский шум к изображению.
"""
noise = np.random.normal(0, sigma / 255.0, image.shape).astype(np.float32)
noisy_image = image.astype(np.float32) / 255.0 + noise
noisy_image = np.clip(noisy_image, 0, 1) * 255.0
return noisy_image.astype(np.uint8)
def gaussian_blur(image, kernel_size=15):
"""
Применяет гауссово размытие к изображению.
:param image: Входное изображение (numpy.ndarray).
:param kernel_size: Размер ядра размытия (нечётное число).
:return: Размытие изображения.
"""
# Применяем гауссово размытие
blurred_image = cv2.GaussianBlur(image, (kernel_size, kernel_size), 0)
return blurred_image
def add_rain_effect(image, rain_type='heavy', rain_density=0.8, drop_length=30, drop_width=2, rain_angle=-15, intensity=150):
"""
Добавляет эффект дождя на изображение (Rain100H или Rain100L).
:param image: Исходное изображение (numpy.ndarray).
:param rain_type: Тип дождя ('heavy' для Rain100H, 'light' для Rain100L).
:param rain_density: Плотность дождя (от 0 до 1), где 1 — максимальная плотность.
:param drop_length: Длина капель дождя.
:param drop_width: Толщина капель дождя.
:param rain_angle: Угол наклона капель (в градусах, отрицательные — влево).
:param intensity: Яркость дождевых капель (от 0 до 255). Чем меньше, тем темнее капли.
:return: Изображение с эффектом дождя.
"""
# Создаём слой дождя (цветное изображение без альфа-канала)
rain_layer = np.zeros_like(image, dtype=np.uint8)
# Настройка плотности дождя в зависимости от типа
if rain_type == 'heavy':
rain_density = rain_density # High density (Rain100H)
drop_length = drop_length # Long streaks
drop_width = drop_width
elif rain_type == 'light':
rain_density = rain_density * 0.5 # Lower density (Rain100L)
drop_length = drop_length // 2 # Shorter streaks
drop_width = max(1, drop_width // 2)
else:
raise ValueError("Invalid rain_type. Use 'heavy' for Rain100H or 'light' for Rain100L.")
# Количество капель дождя
num_drops = int(rain_density * image.shape[0] * image.shape[1] // 1000)
# Генерация капель дождя
for _ in range(num_drops):
# Случайная начальная точка капли
x_start = np.random.randint(0, image.shape[1])
y_start = np.random.randint(0, image.shape[0])
# Конечная точка капли
x_end = int(x_start + drop_length * np.cos(np.radians(rain_angle)))
y_end = int(y_start + drop_length * np.sin(np.radians(rain_angle)))
# Устанавливаем серый цвет для капель. int(intensity) задает одинаковое значение для всех каналов.
gray_value = int(intensity) # Яркость капель (серая шкала)
# Рисуем каплю на rain_layer
# Важно: Убедитесь, что используемый цвет имеет 3 компонента (для BGR)
cv2.line(rain_layer, (x_start, y_start), (x_end, y_end), (gray_value, gray_value, gray_value), thickness=drop_width)
# Добавляем размытие капель для более реалистичного эффекта
blur_size = max(3, drop_width * 2 + 1)
rain_layer = cv2.GaussianBlur(rain_layer, (blur_size, blur_size), 0)
# Смешиваем оригинальное изображение с дождём (капли будут серыми)
rainy_image = cv2.addWeighted(image, 1, rain_layer, 0.5, 0)
return rainy_image
def compare_images(original, before, after, title="Сравнение изображений"):
"""
Отображает три изображения: оригинал, до преобразования и после преобразования.
:param original: Оригинальное изображение (NumPy массив)
:param before: Изображение до преобразования (NumPy массив)
:param after: Изображение после преобразования (NumPy массив)
:param title: Заголовок (необязательно)
"""
plt.figure(figsize=(18, 6))
# Оригинальное изображение
plt.subplot(1, 3, 1)
plt.imshow(cv2.cvtColor(original, cv2.COLOR_BGR2RGB))
plt.title('Оригинал')
plt.axis('off')
# Изображение до преобразования
plt.subplot(1, 3, 2)
plt.imshow(cv2.cvtColor(before, cv2.COLOR_BGR2RGB))
plt.title('До обработки')
plt.axis('off')
# Изображение после преобразования
plt.subplot(1, 3, 3)
plt.imshow(cv2.cvtColor(after, cv2.COLOR_BGR2RGB))
plt.title('После обработки')
plt.axis('off')
# Отображаем все изображения
plt.suptitle(title, fontsize=16)
plt.show()
Загрузка изображения¶
# Загрузка изображения для обработки
upload_image = files.upload()
# Получаем имя загруженного файла
image_name = next(iter(upload_image))
print(f"Обрабатываемое изображение для первого метода: {image_name}")
Saving small.jpg to small.jpg Обрабатываемое изображение для первого метода: small.jpg
Предобработка изображения¶
Оптимизация размера изображения
original_image = cv2.imread(image_name)
optimized_color_image = resize_image_to_multiple_of_16(original_image)
cv2_imshow(optimized_color_image)
Создание цветного изображения
optimized_gray_image = cv2.cvtColor(optimized_color_image, cv2.COLOR_BGR2GRAY)
Создание цветного изображения с эффектом шума
noisy_color_image = add_gaussian_noise(optimized_color_image, sigma=50)
cv2_imshow(noisy_color_image)
Создание цветного изображения с эффектом блюра
blurred_color_image = gaussian_blur(optimized_color_image, 21)
cv2_imshow(blurred_color_image)
Создание цветного изображения с эффектом дождя
rainy_color_image = add_rain_effect(optimized_color_image, rain_type='heavy', rain_density=80, drop_length=10, drop_width=1, rain_angle=90, intensity=255)
cv2_imshow(rainy_color_image)
Создание серого изображения с эффектом шума
noisy_gray_image = add_gaussian_noise(optimized_gray_image, sigma=50)
cv2_imshow(noisy_gray_image)
Создание серого изображения с эффектом блюра
blurred_gray_image = gaussian_blur(optimized_gray_image, 21)
cv2_imshow(blurred_gray_image)
Создание серого изображения с эффектом дождя
rainy_gray_image = add_rain_effect(optimized_gray_image, rain_type='heavy', rain_density=80, drop_length=10, drop_width=1, rain_angle=90, intensity=255)
cv2_imshow(rainy_gray_image)
Реализация первичного кода¶
Функция для обработки изображения
def process_image(image_path, shape_size=64, block_size=15):
"""
Обрабатывает изображение, выполняя преобразование в оттенки серого, инверсию цветов,
адаптивное пороговое преобразование и выделение горизонтальных линий с помощью
морфологических операций.
Применяет модель для очистки изображения от шума.
Параметры:
-----------
image_path : str
Путь к изображению, которое нужно обработать.
block_size : int, optional
Размер блока для адаптивного порогового преобразования (должен быть нечетным числом).
Значение по умолчанию: 15.
Возвращает:
-----------
tuple
Кортеж из трёх изображений:
- gray (numpy.ndarray): Серое изображение после преобразования.
- bw (numpy.ndarray): Бинарное изображение после адаптивного порогового преобразования.
- horizontal (numpy.ndarray): Изображение с выделенными горизонтальными линиями.
Исключения:
-----------
ValueError
Если изображение не удалось загрузить по указанному пути.
"""
img = cv2.imread(image_path)
if img is None:
raise ValueError("Не удалось загрузить изображение. Проверьте файл.")
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
gray = cv2.bitwise_not(gray) # Преобразование в серые оттенки и инверсия
bw = cv2.adaptiveThreshold(
gray,
255,
cv2.ADAPTIVE_THRESH_MEAN_C,
cv2.THRESH_BINARY,
block_size,
-2
)
kernel = np.ones((1, bw.shape[1] // shape_size), np.uint8)
horizontal = cv2.erode(bw, kernel)
horizontal = cv2.dilate(horizontal, kernel)
return gray, bw, horizontal
Обработка изображения и визуализация результатов
gray, bw, horizontal = process_image(image_name, shape_size=8)
plt.figure(figsize=(15, 5))
plt.subplot(1, 3, 1), plt.imshow(gray, cmap='gray'), plt.title('Серое изображение')
plt.subplot(1, 3, 2), plt.imshow(bw, cmap='gray'), plt.title('Пороговое изображение')
plt.subplot(1, 3, 3), plt.imshow(horizontal, cmap='gray'), plt.title('Горизонтальные линии')
plt.suptitle(f'Результат обработки: {image_name}')
plt.show()
Реализация моделей из статьи "Restormer: Efficient Transformer for High-Resolution Image Restoration" (п. 3)¶
Страница на GitHub: https://github.com/swz30/Restormer/
Restormer (Transformer-Based Restoration)
Технология: Transformer.
Особенности:
Преодолевает ограничения CNN (ограниченный размер поля восприятия).
Оптимизирован для работы с изображениями высокого разрешения.
Учитывает долгосрочные зависимости пикселей.
Преимущества:
Эффективен для обработки изображений высокого разрешения.
Превосходные результаты на задачах дерейнинга (deraining), устранения размытости (motion/defocus deblurring), и денойзинга (denoising).
Ограничения:
Более высокая вычислительная сложность.
Требует большего объема данных для обучения, чтобы реализовать преимущества трансформеров.
Загрузка весов моделей¶
Загрузка модели gaussian_gray_denoising_sigma50.pth
file_id = '1a63YoHqwteN7jCBeKeAGsjLP7Sua1jI8'
gdown.download(f'https://drive.google.com/uc?id={file_id}', 'gaussian_gray_denoising_sigma50.pth', quiet=False)
Downloading... From (original): https://drive.google.com/uc?id=1a63YoHqwteN7jCBeKeAGsjLP7Sua1jI8 From (redirected): https://drive.google.com/uc?id=1a63YoHqwteN7jCBeKeAGsjLP7Sua1jI8&confirm=t&uuid=7503f06f-1437-4ef7-ac85-cffa7c5cd801 To: /content/gaussian_gray_denoising_sigma50.pth 100%|██████████| 105M/105M [00:02<00:00, 46.6MB/s]
'gaussian_gray_denoising_sigma50.pth'
Загрузка модели real_denoising.pth
file_id = '189l4sV6jnVHXmQtNKmLXuxZpe75TfkeM'
gdown.download(f'https://drive.google.com/uc?id={file_id}', 'real_denoising.pth', quiet=False)
Downloading... From (original): https://drive.google.com/uc?id=189l4sV6jnVHXmQtNKmLXuxZpe75TfkeM From (redirected): https://drive.google.com/uc?id=189l4sV6jnVHXmQtNKmLXuxZpe75TfkeM&confirm=t&uuid=c003ba8f-f01a-49b9-8a44-b2e90574aa40 To: /content/real_denoising.pth 100%|██████████| 105M/105M [00:02<00:00, 51.6MB/s]
'real_denoising.pth'
Загрузка модели gaussian_color_denoising_sigma50.pth
file_id = '1aDTuhywtgV1v-gvwJu8eyVrrbnKyMZm7'
gdown.download(f'https://drive.google.com/uc?id={file_id}', 'gaussian_color_denoising_sigma50.pth', quiet=False)
Downloading... From (original): https://drive.google.com/uc?id=1aDTuhywtgV1v-gvwJu8eyVrrbnKyMZm7 From (redirected): https://drive.google.com/uc?id=1aDTuhywtgV1v-gvwJu8eyVrrbnKyMZm7&confirm=t&uuid=ff64ba8a-1cb9-46bf-a0ee-72a97d10f9f1 To: /content/gaussian_color_denoising_sigma50.pth 100%|██████████| 105M/105M [00:01<00:00, 53.0MB/s]
'gaussian_color_denoising_sigma50.pth'
Загрузка модели single_image_defocus_deblurring.pth
file_id = '1W9R_491RLjr9JU2mun1hri5hDP2UndOW'
gdown.download(f'https://drive.google.com/uc?id={file_id}', 'single_image_defocus_deblurring.pth', quiet=False)
Downloading... From (original): https://drive.google.com/uc?id=1W9R_491RLjr9JU2mun1hri5hDP2UndOW From (redirected): https://drive.google.com/uc?id=1W9R_491RLjr9JU2mun1hri5hDP2UndOW&confirm=t&uuid=d46d8462-253c-4a24-84ff-1ba5a721f84f To: /content/single_image_defocus_deblurring.pth 100%|██████████| 105M/105M [00:01<00:00, 75.5MB/s]
'single_image_defocus_deblurring.pth'
Загрузка модели deraining.pth
file_id = '1NNsBEl8rBKec7OAKhhzRIMIFrmWNB60D'
gdown.download(f'https://drive.google.com/uc?id={file_id}', 'deraining.pth', quiet=False)
Downloading... From (original): https://drive.google.com/uc?id=1NNsBEl8rBKec7OAKhhzRIMIFrmWNB60D From (redirected): https://drive.google.com/uc?id=1NNsBEl8rBKec7OAKhhzRIMIFrmWNB60D&confirm=t&uuid=176cdfc8-edce-4378-bd91-89ebdacca3ca To: /content/deraining.pth 100%|██████████| 105M/105M [00:02<00:00, 41.7MB/s]
'deraining.pth'
Клонирование репозитория и настройка параметров для инициализации моделей¶
# Клонирование репозитория с GitHub
!git clone https://github.com/swz30/Restormer.git
Cloning into 'Restormer'... remote: Enumerating objects: 309, done. remote: Counting objects: 100% (107/107), done. remote: Compressing objects: 100% (51/51), done. remote: Total 309 (delta 67), reused 56 (delta 56), pack-reused 202 (from 1) Receiving objects: 100% (309/309), 1.56 MiB | 23.14 MiB/s, done. Resolving deltas: 100% (123/123), done.
# Путь к директории, содержащей restormer_arch.py
sys.path.append(os.path.abspath('Restormer/basicsr/models/archs'))
# Импорт класса Restormer
from restormer_arch import Restormer
# Определение устройства
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"Используемое устройство: {device}")
Используемое устройство: cpu
model_real_denoising = 'real_denoising.pth'
model_gaussian_color_denoising = 'gaussian_color_denoising_sigma50.pth'
model_gaussian_gray_denoising = 'gaussian_gray_denoising_sigma50.pth'
# Перемещение моделей в директорию pretrained_models
!mkdir -p Restormer/basicsr/models/pretrained_models
!mv {model_real_denoising} Restormer/basicsr/models/pretrained_models/
!mv {model_gaussian_color_denoising} Restormer/basicsr/models/pretrained_models/
!mv {model_gaussian_gray_denoising} Restormer/basicsr/models/pretrained_models/
Инициализация функций¶
# Функция для загрузки модели RealDenoising_Restormer и GaussianColorDenoising_RestormerSigma50
def load_model_real_gaussian_color(model_path, device):
model = Restormer(
inp_channels=3,
out_channels=3,
dim=48,
num_blocks=[4,6,6,8],
num_refinement_blocks=4,
heads=[1,2,4,8],
ffn_expansion_factor=2.66,
bias=False,
LayerNorm_type='BiasFree',
dual_pixel_task=False
)
# Загрузка чекпоинта
checkpoint = torch.load(model_path, map_location=device)
# Извлечение state_dict
if 'params' in checkpoint:
state_dict = checkpoint['params']
elif 'state_dict' in checkpoint:
state_dict = checkpoint['state_dict']
else:
state_dict = checkpoint
# Загрузка state_dict в модель
model.load_state_dict(state_dict, strict=True)
model.eval()
model.to(device)
return model
# Функция для загрузки модели GaussianGrayDenoising_RestormerSigma50
def load_model_gaussian_gray(model_path, device):
model = Restormer(
inp_channels=1,
out_channels=1,
dim=48,
num_blocks=[4,6,6,8],
num_refinement_blocks=4,
heads=[1,2,4,8],
ffn_expansion_factor=2.66,
bias=False,
LayerNorm_type='BiasFree',
dual_pixel_task=False
)
# Загрузка чекпоинта
checkpoint = torch.load(model_path, map_location=device)
# Извлечение state_dict
if 'params' in checkpoint:
state_dict = checkpoint['params']
elif 'state_dict' in checkpoint:
state_dict = checkpoint['state_dict']
else:
state_dict = checkpoint
# Загрузка state_dict в модель
model.load_state_dict(state_dict, strict=True)
model.eval()
model.to(device)
return model
def load_model_single_image_defocus_deblurring(model_path, device):
"""
Загружает модель Restormer для задачи дефокусной деразмы.
Args:
model_path (str): Путь к файлу весов модели.
device (torch.device): Устройство для вычислений (CPU или GPU).
Returns:
torch.nn.Module: Загруженная модель в режиме оценки.
"""
# Инициализация модели с параметрами из конфигурации
model = Restormer(
inp_channels=3,
out_channels=3,
dim=48,
num_blocks=[4,6,6,8],
num_refinement_blocks=4,
heads=[1,2,4,8],
ffn_expansion_factor=2.66,
bias=False,
LayerNorm_type='WithBias',
dual_pixel_task=False
)
# Загрузка чекпоинта
checkpoint = torch.load(model_path, map_location=device)
# Извлечение state_dict
if 'params' in checkpoint:
state_dict = checkpoint['params']
elif 'state_dict' in checkpoint:
state_dict = checkpoint['state_dict']
else:
state_dict = checkpoint
# Проверка ключей
missing_keys, unexpected_keys = model.load_state_dict(state_dict, strict=False)
if missing_keys:
print(f"Пропущенные ключи при загрузке модели: {missing_keys}")
if unexpected_keys:
print(f"Неожиданные ключи при загрузке модели: {unexpected_keys}")
# Перевод модели на устройство
model = model.to(device)
# Оборачивание модели в DataParallel, если доступно несколько GPU
if torch.cuda.device_count() > 1:
model = nn.DataParallel(model)
# Перевод модели в режим оценки
model.eval()
return model
# Функция для загрузки модели Deraining_Restormer
def load_model_deraining(model_path, device):
model = Restormer(
inp_channels=3,
out_channels=3,
dim=48,
num_blocks=[4,6,6,8],
num_refinement_blocks=4,
heads=[1,2,4,8],
ffn_expansion_factor=2.66,
bias=False,
LayerNorm_type='WithBias',
dual_pixel_task=False
)
# Загрузка чекпоинта
checkpoint = torch.load(model_path, map_location=device)
# Извлечение state_dict
if 'params' in checkpoint:
state_dict = checkpoint['params']
elif 'state_dict' in checkpoint:
state_dict = checkpoint['state_dict']
else:
state_dict = checkpoint
# Загрузка state_dict в модель
model.load_state_dict(state_dict, strict=True)
model.eval()
model.to(device)
return model
# Функция для денойзинга изображения
def denoise_image(model, image, device):
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
pil_image = Image.fromarray(image_rgb)
# Преобразования
transform = transforms.ToTensor()
input_tensor = transform(pil_image).unsqueeze(0).to(device)
with torch.no_grad():
output = model(input_tensor)
output = output.squeeze().cpu()
output = transforms.ToPILImage()(output.clamp(0, 1))
denoised_rgb = np.array(output)
denoised_bgr = cv2.cvtColor(denoised_rgb, cv2.COLOR_RGB2BGR)
return denoised_bgr
def denoise_gray_image(model, image, device, block_size=11):
# Если изображение цветное, преобразуем в оттенки серого
if len(image.shape) == 3 and image.shape[2] == 3:
gray_image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
else:
gray_image = image
# Нормализуем изображение в диапазон [0, 1]
gray_image = gray_image / 255.0
# Добавляем размерности batch (1) и канала (1)
input_tensor = torch.tensor(gray_image[np.newaxis, np.newaxis, :, :], dtype=torch.float32).to(device)
# Подаём данные в модель
with torch.no_grad():
output = model(input_tensor) # Модель принимает (1, 1, H, W)
# Преобразуем результат обратно в NumPy массив
output = output.squeeze().cpu().numpy()
# Масштабируем результат обратно в диапазон [0, 255]
denoised_gray = (output * 255).clip(0, 255).astype('uint8')
return denoised_gray
def deblur_image(model, image, device):
"""
Применяет модель деразмывания к изображению с отладочными принтами.
Args:
model (torch.nn.Module): Обученная модель деразмывания.
image (numpy.ndarray): Входное изображение в формате BGR.
device (torch.device): Устройство для вычислений (CPU или GPU).
Returns:
numpy.ndarray: Дезабрентое изображение в формате BGR.
"""
if isinstance(model, nn.DataParallel):
actual_model = model.module
else:
actual_model = model
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB).astype(np.float32) / 255.0
print(f"Input Image: dtype={image_rgb.dtype}, min={image_rgb.min()}, max={image_rgb.max()}")
if image_rgb.ndim != 3 or image_rgb.shape[2] != 3:
raise ValueError("Входное изображение должно иметь 3 канала (BGR).")
input_tensor = torch.from_numpy(image_rgb).permute(2, 0, 1).unsqueeze(0).to(device)
print(f"Input Tensor: shape={input_tensor.shape}, dtype={input_tensor.dtype}, device={input_tensor.device}")
actual_model.eval()
with torch.no_grad():
output = actual_model(input_tensor)
print(f"Output Tensor Before Clamping: shape={output.shape}, min={output.min()}, max={output.max()}")
output = torch.clamp(output, 0.0, 1.0)
print(f"Output Tensor After Clamping: min={output.min()}, max={output.max()}")
output_image = output.squeeze(0).permute(1, 2, 0).cpu().numpy()
output_image = (output_image * 255.0).round().astype(np.uint8)
print(f"Output Image: dtype={output_image.dtype}, min={output_image.min()}, max={output_image.max()}")
deblurred_bgr = cv2.cvtColor(output_image, cv2.COLOR_RGB2BGR)
return deblurred_bgr
# Функция для удаления дождевых капель с использованием модели
def derain_image(model, image, device):
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
pil_image = Image.fromarray(image_rgb)
# Преобразования изображения для подачи в модель
transform = transforms.ToTensor()
input_tensor = transform(pil_image).unsqueeze(0).to(device)
with torch.no_grad():
output = model(input_tensor)
output = output.squeeze().cpu()
output = transforms.ToPILImage()(output.clamp(0, 1))
derained_rgb = np.array(output)
derained_bgr = cv2.cvtColor(derained_rgb, cv2.COLOR_RGB2BGR)
return derained_bgr
Реализация модели Real_Denoising¶
# Загрузка модели RealDenoising_Restormer
model_real_denoising_path = 'Restormer/basicsr/models/pretrained_models/real_denoising.pth'
model_real_denoising = load_model_real_gaussian_color(model_real_denoising_path, device)
print("Модель RealDenoising_Restormer успешно загружена.")
<ipython-input-30-05fad0ab12dc>:17: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature. checkpoint = torch.load(model_path, map_location=device)
Модель RealDenoising_Restormer успешно загружена.
# Применение моделей денойзинга для цветных изображений
denoised_real = denoise_image(model_real_denoising, noisy_color_image, device)
# Сравнение исходного изображения с результатами моделей
compare_images(optimized_color_image, noisy_color_image, denoised_real, title='Обработка изображения моделью Restormer_Real_Denoising')
Проверка захвата горизонтальных и вертикальных линий на изображении
# Тест изображения c шумом
test_image(noisy_color_image, shape_size=8, title='Результат обработки изображения с шумом')
# Тест изображения после обработки
test_image(denoised_real, shape_size=8, title='Результат обработки изображения после удаления шума при помощи модели Restormer_Real_Denoising')
Проверка показаний SSIM:
ssim_value_noise = calculate_ssim(optimized_color_image, noisy_color_image, border=0)
print(f"SSIM (Original vs Noise): {ssim_value_noise:.4f}")
SSIM (Original vs Noise): 0.3647
ssim_value_denoised = calculate_ssim(optimized_color_image, denoised_real, border=0)
print(f"SSIM (Original vs Denoised): {ssim_value_denoised:.4f}")
SSIM (Original vs Denoised): 0.8783
Проверка показаний PSNR:
psnr_value_noise = calculate_psnr(optimized_color_image, noisy_color_image, border=0)
print(f"PSNR (Original vs Noise): {psnr_value_noise:.2f} dB")
PSNR (Original vs Noise): 16.72 dB
psnr_value_denoised = calculate_psnr(optimized_color_image, denoised_real, border=0)
print(f"PSNR (Original vs Denoised): {psnr_value_denoised:.2f} dB")
PSNR (Original vs Denoised): 21.00 dB
Реализация модели Gaussian_Color_Denoising_Sigma50¶
# Загрузка модели GaussianColorDenoising_RestormerSigma50
model_gaussian_color_denoising_path = 'Restormer/basicsr/models/pretrained_models/gaussian_color_denoising_sigma50.pth'
model_gaussian_color_denoising = load_model_real_gaussian_color(model_gaussian_color_denoising_path, device)
print("Модель GaussianColorDenoising_RestormerSigma50 успешно загружена.")
<ipython-input-30-05fad0ab12dc>:17: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature. checkpoint = torch.load(model_path, map_location=device)
Модель GaussianColorDenoising_RestormerSigma50 успешно загружена.
# Применение модели
denoised_gaussian_color = denoise_image(model_gaussian_color_denoising, noisy_color_image, device)
# Сравнение исходного изображения с результатами моделей
compare_images(optimized_color_image, noisy_color_image, denoised_gaussian_color, title='Обработка изображения моделью Restormer_Gaussian_Color_Denoising')
Проверка захвата горизонтальных линий на изображении
# Тест изображения c шумом
test_image(noisy_color_image, shape_size=8, title='Результат обработки изображения с шумом')
# Тест изображения после преобразования
test_image(denoised_gaussian_color, shape_size=8, title='Результат обработки изображения после удаления шума при помощи модели Restormer_Gaussian_Color_Denoising')
Проверка показаний SSIM:
ssim_value_noise = calculate_ssim(optimized_color_image, noisy_color_image, border=0)
print(f"SSIM (Original vs Noise): {ssim_value_noise:.4f}")
SSIM (Original vs Noise): 0.3647
ssim_value_denoised = calculate_ssim(optimized_color_image, denoised_gaussian_color, border=0)
print(f"SSIM (Original vs Denoised): {ssim_value_denoised:.4f}")
SSIM (Original vs Denoised): 0.9751
Проверка показаний PSNR:
psnr_value_noise = calculate_psnr(optimized_color_image, noisy_color_image, border=0)
print(f"PSNR (Original vs Noise): {psnr_value_noise:.2f} dB")
PSNR (Original vs Noise): 16.72 dB
psnr_value_denoised = calculate_psnr(optimized_color_image, denoised_gaussian_color, border=0)
print(f"PSNR (Original vs Denoised): {psnr_value_denoised:.2f} dB")
PSNR (Original vs Denoised): 22.32 dB
Реализация модели Gaussian_Gray_Denoising_Sigma50¶
# Загрузка модели GaussianGrayDenoising_RestormerSigma50
model_gaussian_gray_denoising_path = 'Restormer/basicsr/models/pretrained_models/gaussian_gray_denoising_sigma50.pth'
model_gaussian_gray_denoising = load_model_gaussian_gray(model_gaussian_gray_denoising_path, device)
print("Модель GaussianGrayDenoising_RestormerSigma50 успешно загружена.")
Модель GaussianGrayDenoising_RestormerSigma50 успешно загружена.
<ipython-input-31-6512969741a0>:17: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature. checkpoint = torch.load(model_path, map_location=device)
# Применение модели
denoised_gaussian_gray = denoise_gray_image(model_gaussian_gray_denoising, noisy_gray_image, device)
# Сравнение изображений
compare_images(optimized_gray_image, noisy_gray_image, denoised_gaussian_gray, title='Обработка изображения моделью Restormer_Gaussian_Gray_Denoising')
Проверка захвата горизонтальных линий на изображении
# Тест изображения c шумом
test_image_gray(noisy_gray_image, shape_size=8, title='Результат обработки изображения с шумом')
# Тест изображения после преобразования
test_image_gray(denoised_gaussian_gray, shape_size=8, title='Результат обработки изображения после удаления шума при помощи модели Restormer_Gaussian_Gray_Denoising')
Проверка показаний SSIM:
ssim_value_noise = calculate_ssim(optimized_gray_image, noisy_gray_image, border=0)
print(f"SSIM (Original vs Noise): {ssim_value_noise:.4f}")
SSIM (Original vs Noise): 0.3645
ssim_value_denoised = calculate_ssim(optimized_gray_image, denoised_gaussian_gray, border=0)
print(f"SSIM (Original vs Denoised): {ssim_value_denoised:.4f}")
SSIM (Original vs Denoised): 0.9644
Проверка показаний PSNR:
psnr_value_noise = calculate_psnr(optimized_gray_image, noisy_gray_image, border=0)
print(f"PSNR (Original vs Noise): {psnr_value_noise:.2f} dB")
PSNR (Original vs Noise): 16.71 dB
psnr_value_denoised = calculate_psnr(optimized_gray_image, denoised_gaussian_gray, border=0)
print(f"PSNR (Original vs Denoised): {psnr_value_denoised:.2f} dB")
PSNR (Original vs Denoised): 21.77 dB
Реализация модели Single_Image_Defocus_Deblurring¶
# Загрузка модели Single_Image_Defocus_Deblurring
model_single_image_defocus_deblurring_path = 'single_image_defocus_deblurring.pth'
model_single_image_defocus_deblurring = load_model_single_image_defocus_deblurring(model_single_image_defocus_deblurring_path, device)
print("Модель Single_Image_Defocus_Deblurring успешно загружена.")
Модель Single_Image_Defocus_Deblurring успешно загружена.
<ipython-input-32-a8bbaaf6f20e>:27: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature. checkpoint = torch.load(model_path, map_location=device)
# Применение модели
defocus_deblurring = deblur_image(model_single_image_defocus_deblurring, blurred_color_image, device)
Input Image: dtype=float32, min=0.3921568691730499, max=1.0 Input Tensor: shape=torch.Size([1, 3, 384, 1280]), dtype=torch.float32, device=cpu Output Tensor Before Clamping: shape=torch.Size([1, 3, 384, 1280]), min=0.41056251525878906, max=1.0069262981414795 Output Tensor After Clamping: min=0.41056251525878906, max=1.0 Output Image: dtype=uint8, min=105, max=255
# Сравнение изображений
compare_images(optimized_color_image, blurred_color_image, defocus_deblurring, title='Обработка изображения моделью Restormer_Defocus_Deblurring')
Проверка захвата горизонтальных и вертикальных линий на изображении
# Тест изображения c блюром
test_image(blurred_color_image, shape_size=8, title='Результат обработки изображения с блюром')
# Тест изображения после преобразования
test_image(defocus_deblurring, shape_size=8, title='Результат обработки изображения после удаления блюра при помощи модели Restormer_Restormer_Defocus_Deblurring')
Проверка показаний SSIM:
ssim_value_blur = calculate_ssim(optimized_color_image, blurred_color_image, border=0)
print(f"SSIM (Original vs Blur): {ssim_value_blur:.4f}")
SSIM (Original vs Blur): 0.5960
ssim_value_deblurred = calculate_ssim(optimized_color_image, defocus_deblurring, border=0)
print(f"SSIM (Original vs Deblurred): {ssim_value_deblurred:.4f}")
SSIM (Original vs Deblurred): 0.5893
Проверка показаний PSNR:
psnr_value_blur = calculate_psnr(optimized_color_image, blurred_color_image, border=0)
print(f"PSNR (Original vs Blur): {psnr_value_blur:.2f} dB")
PSNR (Original vs Blur): 15.07 dB
psnr_value_deblurred = calculate_psnr(optimized_color_image, defocus_deblurring, border=0)
print(f"PSNR (Original vs Deblurred): {psnr_value_deblurred:.2f} dB")
PSNR (Original vs Deblurred): 15.10 dB
Реализация модели Deraining¶
# Загрузка модели Deraining
model_deraining_path = 'deraining.pth'
model_deraining = load_model_deraining(model_deraining_path, device)
print("Модель Deraining успешно загружена.")
Модель Deraining успешно загружена.
<ipython-input-33-8fe1cabeb3e0>:17: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature. checkpoint = torch.load(model_path, map_location=device)
# Применение модели
deraining = derain_image(model_deraining, rainy_color_image, device)
# Сравнение изображений
compare_images(optimized_color_image, rainy_color_image, deraining, title='Обработка изображения моделью Restormer_Deraining')
Проверка захвата горизонтальных и вертикальных линий на изображении
# Тест изображения c эффектом дождя
test_image(rainy_color_image, shape_size=8, title='Результат обработки изображения с эффектом дождя')
# Тест изображения после преобразования
test_image(deraining, shape_size=8, title='Результат обработки изображения после удаления эффекта дождя при помощи модели Restormer_Restormer_Defocus_Deblurring')
Проверка показаний SSIM:
ssim_value_blur = calculate_ssim(optimized_color_image, rainy_color_image, border=0)
print(f"SSIM (Original vs Rainy): {ssim_value_blur:.4f}")
SSIM (Original vs Rainy): 0.8959
ssim_value_deblurred = calculate_ssim(optimized_color_image, deraining, border=0)
print(f"SSIM (Original vs Derained): {ssim_value_deblurred:.4f}")
SSIM (Original vs Derained): 0.9838
Проверка показаний PSNR:
psnr_value_blur = calculate_psnr(optimized_color_image, rainy_color_image, border=0)
print(f"PSNR (Original vs Rainy): {psnr_value_blur:.2f} dB")
PSNR (Original vs Rainy): 19.16 dB
psnr_value_deblurred = calculate_psnr(optimized_color_image, deraining, border=0)
print(f"PSNR (Original vs Derained): {psnr_value_deblurred:.2f} dB")
PSNR (Original vs Derained): 30.98 dB
Реализация моделей из статьи "Plug-and-Play Image Restoration with Deep Denoiser Prior" (п. 21)¶
Страница на GitHub: https://github.com/cszn/DPIR/
DRUNet (Plug-and-Play Image Restoration)
Технология: CNN.
Особенности:
Глубокая сверточная сеть для подавления шума (denoising).
Используется в качестве модуля в алгоритме восстановления, основанном на разбиении полуквадратичной ошибки (HQ-Split).
Фокусируется на универсальности и гибкости.
Преимущества:
Легкость интеграции в существующие модельные методы.
Отличные результаты на задачах размытости (deblurring), суперразрешения
(super-resolution), демозаики (demosaicing).
- Поддерживает обработку изображений с низким шумом.
Ограничения:
Не оптимизирован для обработки изображений высокого разрешения.
Зависимость от архитектуры CNN может ограничивать способность к моделированию долгосрочных зависимостей в данных.
Клонирование репозитория с GitHub¶
!git clone https://github.com/cszn/DPIR.git
Cloning into 'DPIR'... remote: Enumerating objects: 239, done. remote: Counting objects: 100% (60/60), done. remote: Compressing objects: 100% (25/25), done. remote: Total 239 (delta 48), reused 35 (delta 35), pack-reused 179 (from 1) Receiving objects: 100% (239/239), 6.85 MiB | 37.31 MiB/s, done. Resolving deltas: 100% (104/104), done.
Загрузка весов моделей¶
Загрузка весов drunet_color.pth
file_id = '1CZ5zZouKfxilpTPgYdlw_OoYowSZ-959'
gdown.download(f'https://drive.google.com/uc?id={file_id}', 'drunet_color.pth', quiet=False)
Downloading... From (original): https://drive.google.com/uc?id=1CZ5zZouKfxilpTPgYdlw_OoYowSZ-959 From (redirected): https://drive.google.com/uc?id=1CZ5zZouKfxilpTPgYdlw_OoYowSZ-959&confirm=t&uuid=1dd4940a-294c-4d8f-bca1-fe0826e279f8 To: /content/drunet_color.pth 100%|██████████| 131M/131M [00:01<00:00, 88.5MB/s]
'drunet_color.pth'
Загрузка весов drunet_gray.pth
file_id = '1s73xuQ37Vqc-KGczVlNDsvXFI7N1iw0M'
gdown.download(f'https://drive.google.com/uc?id={file_id}', 'drunet_gray.pth', quiet=False)
Downloading... From (original): https://drive.google.com/uc?id=1s73xuQ37Vqc-KGczVlNDsvXFI7N1iw0M From (redirected): https://drive.google.com/uc?id=1s73xuQ37Vqc-KGczVlNDsvXFI7N1iw0M&confirm=t&uuid=28103d29-793c-4df5-af4a-7c7905ae8511 To: /content/drunet_gray.pth 100%|██████████| 131M/131M [00:02<00:00, 54.7MB/s]
'drunet_gray.pth'
Инициализация функций¶
# Переходим в директорию репозитория DPIR
%cd DPIR
from models.network_unet import UNetRes as DRUNet
from utils import utils_image as util
%cd ..
/content/DPIR /content
def load_drunet_model_color(weight_path, device):
"""
Загрузка модели DRUNet с весами.
:param weight_path: Путь к файлу весов (drunet_color.pth)
:param device: Устройство для вычислений (CPU/GPU)
:return: DRUNet модель с загруженными весами
"""
# Инициализируем модель с параметрами из примера
model = DRUNet(
in_nc=4,
out_nc=3,
nc=[64, 128, 256, 512],
nb=4,
act_mode='R',
downsample_mode='strideconv',
upsample_mode='convtranspose'
)
# Загружаем веса
weights = torch.load(weight_path, map_location=device, weights_only=True)
model.load_state_dict(weights, strict=True)
model.eval()
model.to(device)
return model
def process_image_with_drunet_color(model, image, noise_level, device):
"""
Применяет модель DRUNet к изображению с использованием utils_model.test_mode для обработки некратных размеров.
"""
from utils import utils_model
# Конвертируем изображение в формат float32 и нормализуем в диапазон [0, 1]
image = util.uint2single(image)
# Преобразуем изображение в тензор с размерностью (1, 3, H, W)
image_tensor = util.single2tensor4(image).to(device)
# Добавляем уровень шума как четвёртый канал
noise_level_tensor = torch.full(
(1, 1, image_tensor.shape[2], image_tensor.shape[3]),
noise_level / 255.0,
device=device
)
input_tensor = torch.cat((image_tensor, noise_level_tensor), dim=1)
# Используем test_mode для обработки изображения моделью
with torch.no_grad():
output_tensor = utils_model.test_mode(model, input_tensor, refield=64, mode=5)
# Преобразуем результат обратно в формат uint8
output_image = util.tensor2uint(output_tensor)
return output_image
def load_drunet_model_gray(weight_path, device):
"""
Загрузка модели DRUNet для серых изображений.
"""
model = DRUNet(
in_nc=2, # 1 канал для изображения + 1 канал для уровня шума
out_nc=1, # 1 канал для серого изображения
nc=[64, 128, 256, 512],
nb=4,
act_mode='R',
downsample_mode='strideconv',
upsample_mode='convtranspose'
)
# Загружаем веса
weights = torch.load(weight_path, map_location=device)
model.load_state_dict(weights, strict=True)
model.eval()
model.to(device)
return model
def process_image_with_drunet_gray(model, image, noise_level, device):
"""
Применяет модель DRUNet (drunet_gray) к серому изображению.
"""
from utils import utils_model
# Конвертируем изображение в формат float32 и нормализуем в диапазон [0, 1]
image = util.uint2single(image)
# Преобразуем изображение в тензор с размерностью (1, 1, H, W)
image_tensor = torch.from_numpy(image).unsqueeze(0).unsqueeze(0).to(device)
# Добавляем уровень шума как второй канал
noise_level_tensor = torch.full(
(1, 1, image_tensor.shape[2], image_tensor.shape[3]),
noise_level / 255.0,
device=device
)
input_tensor = torch.cat((image_tensor, noise_level_tensor), dim=1)
# Используем test_mode для обработки изображения моделью
with torch.no_grad():
output_tensor = utils_model.test_mode(model, input_tensor, refield=64, mode=5)
# Преобразуем результат обратно в формат uint8
output_image = util.tensor2uint(output_tensor.squeeze(0).squeeze(0))
return output_image
Загрузка моделей¶
# Проверяем, доступен ли GPU
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print(f'Используется устройство: {device}')
Используется устройство: cpu
Загрузка модели DRUNet (color)
# Путь к файлу весов
weights_path_color = '/content/drunet_color.pth'
# Загрузка модели для цветных изображений
drunet_model = load_drunet_model_color(weights_path_color, device)
print('Модель DRUNet (color) успешно загружена.')
Модель DRUNet (color) успешно загружена.
Загрузка модели DRUNet (gray)
# Путь к файлу весов
weights_path_gray = '/content/drunet_gray.pth'
# Загрузка модели для серых изображений
drunet_model_gray = load_drunet_model_gray(weights_path_gray, device)
print('Модель DRUNet (gray) успешно загружена.')
Модель DRUNet (gray) успешно загружена.
<ipython-input-241-447e61a67910>:16: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature. weights = torch.load(weight_path, map_location=device)
Реализцаия модели DRU-net (color) для удаления шума¶
# Применяем модель для удаления шума
denoised_drunet_color_image = process_image_with_drunet_color(drunet_model, noisy_color_image, 50, device)
# Сравнение изображений
compare_images(optimized_color_image, noisy_color_image, denoised_drunet_color_image, title='Обработка изображения моделью DRU-net_(color)')
Проверка захвата горизонтальных линий на изображении
# Тест изображения c шумом
test_image(noisy_color_image, shape_size=8, title='Результат обработки изображения с шумом')
# Тест изображения после преобразования
test_image(denoised_drunet_color_image, shape_size=8, title='Результат обработки изображения после удаления шума при помощи модели DRU-net_(color)')
Проверка показаний SSIM:
ssim_value_noise = calculate_ssim(optimized_color_image, noisy_color_image, border=0)
print(f"SSIM (Original vs Noise): {ssim_value_noise:.4f}")
SSIM (Original vs Noise): 0.3647
ssim_value_denoised = calculate_ssim(optimized_color_image, denoised_drunet_color_image, border=0)
print(f"SSIM (Original vs Denoised): {ssim_value_denoised:.4f}")
SSIM (Original vs Denoised): 0.9742
Проверка показаний PSNR:
psnr_value_noise = calculate_psnr(optimized_color_image, noisy_color_image, border=0)
print(f"PSNR (Original vs Noise): {psnr_value_noise:.2f} dB")
PSNR (Original vs Noise): 16.72 dB
psnr_value_denoised = calculate_psnr(optimized_color_image, denoised_drunet_color_image, border=0)
print(f"PSNR (Original vs Denoised): {psnr_value_denoised:.2f} dB")
PSNR (Original vs Denoised): 22.42 dB
Реализцаия модели DRU-net (color) для удаления блюра¶
# Применяем модель для удаления блюра
deblurred_drunet_color_image = process_image_with_drunet_color(drunet_model, blurred_color_image, 50, device)
# Сравнение изображений
compare_images(optimized_color_image, blurred_color_image, deblurred_drunet_color_image, title='Обработка изображения моделью DRU-net_(color)')
Проверка захвата горизонтальных линий на изображении
# Тест изображения c блюром
test_image(blurred_color_image, shape_size=8, title='Результат обработки изображения с блюром')
# Тест изображения после преобразования
test_image(deblurred_drunet_color_image, shape_size=8, title='Результат обработки изображения после удаления блюра при помощи модели DRU-net_(color)')
Проверка показаний SSIM:
ssim_value_noise = calculate_ssim(optimized_color_image, blurred_color_image, border=0)
print(f"SSIM (Original vs Blur): {ssim_value_noise:.4f}")
SSIM (Original vs Blur): 0.5960
ssim_value_denoised = calculate_ssim(optimized_color_image, deblurred_drunet_color_image, border=0)
print(f"SSIM (Original vs Deblurred): {ssim_value_denoised:.4f}")
SSIM (Original vs Deblurred): 0.5839
Проверка показаний PSNR:
psnr_value_noise = calculate_psnr(optimized_color_image, blurred_color_image, border=0)
print(f"PSNR (Original vs Blur): {psnr_value_noise:.2f} dB")
PSNR (Original vs Blur): 15.07 dB
psnr_value_denoised = calculate_psnr(optimized_color_image, deblurred_drunet_color_image, border=0)
print(f"PSNR (Original vs Deblurred): {psnr_value_denoised:.2f} dB")
PSNR (Original vs Deblurred): 14.91 dB
Реализцаия модели DRU-net (color) для удаления эффекта дождя¶
# Применяем модель для удаления эффекта дождя
derained_drunet_color_image = process_image_with_drunet_color(drunet_model, rainy_color_image, 50, device)
# Сравнение изображений
compare_images(optimized_color_image, rainy_color_image, derained_drunet_color_image, title='Обработка изображения моделью DRU-net_(color)')
Проверка захвата горизонтальных линий на изображении
# Тест изображения c эффектом дождя
test_image(rainy_color_image, shape_size=4, title='Результат обработки изображения с эффектом дождя')
# Тест изображения после преобразования
test_image(derained_drunet_color_image, shape_size=4, title='Результат обработки изображения после удаления эффекта дождя при помощи модели DRU-net_(color)')
Проверка показаний SSIM:
ssim_value_noise = calculate_ssim(optimized_color_image, rainy_color_image, border=0)
print(f"SSIM (Original vs Rainy): {ssim_value_noise:.4f}")
SSIM (Original vs Rainy): 0.8959
ssim_value_denoised = calculate_ssim(optimized_color_image, derained_drunet_color_image, border=0)
print(f"SSIM (Original vs Derained): {ssim_value_denoised:.4f}")
SSIM (Original vs Derained): 0.8944
Проверка показаний PSNR:
psnr_value_noise = calculate_psnr(optimized_color_image, rainy_color_image, border=0)
print(f"PSNR (Original vs Rainy): {psnr_value_noise:.2f} dB")
PSNR (Original vs Rainy): 19.16 dB
psnr_value_denoised = calculate_psnr(optimized_color_image, derained_drunet_color_image, border=0)
print(f"PSNR (Original vs Derained): {psnr_value_denoised:.2f} dB")
PSNR (Original vs Derained): 19.26 dB
Реализцаия модели DRU-net (gray) для удаления шума¶
# Применяем модель для удаления шума
denoised_drunet_gray_image = process_image_with_drunet_gray(drunet_model_gray, noisy_gray_image, 50, device)
# Сравнение изображений
compare_images(optimized_gray_image, noisy_gray_image, denoised_drunet_gray_image, title='Обработка изображения моделью DRU-net_(gray)')
Проверка захвата горизонтальных линий на изображении
# Тест изображения c шумом
test_image_gray(noisy_gray_image, shape_size=8, title='Результат обработки изображения с шумом')
# Тест изображения после преобразования
test_image_gray(denoised_drunet_gray_image, shape_size=8, title='Результат обработки изображения после удаления шума при помощи модели DRU-net_(gray)')
Проверка показаний SSIM:
ssim_value_noise = calculate_ssim(optimized_gray_image, noisy_gray_image, border=0)
print(f"SSIM (Original vs Noise): {ssim_value_noise:.4f}")
SSIM (Original vs Noise): 0.3645
ssim_value_denoised = calculate_ssim(optimized_gray_image, denoised_drunet_gray_image, border=0)
print(f"SSIM (Original vs Denoised): {ssim_value_denoised:.4f}")
SSIM (Original vs Denoised): 0.9674
Проверка показаний PSNR:
psnr_value_noise = calculate_psnr(optimized_gray_image, noisy_gray_image, border=0)
print(f"PSNR (Original vs Noise): {psnr_value_noise:.2f} dB")
PSNR (Original vs Noise): 16.71 dB
psnr_value_denoised = calculate_psnr(optimized_gray_image, denoised_drunet_gray_image, border=0)
print(f"PSNR (Original vs Denoised): {psnr_value_denoised:.2f} dB")
PSNR (Original vs Denoised): 22.04 dB
Реализцаия модели DRU-net (gray) для удаления блюра¶
# Применяем модель для удаления блюра
deblurred_drunet_gray_image = process_image_with_drunet_gray(drunet_model_gray, blurred_gray_image, 50, device)
# Сравнение изображений
compare_images(optimized_gray_image, blurred_gray_image, deblurred_drunet_gray_image, title='Обработка изображения моделью DRU-net_(gray)')
Проверка захвата горизонтальных линий на изображении
# Тест изображения c блюром
test_image_gray(blurred_gray_image, shape_size=8, title='Результат обработки изображения с блюром')
# Тест изображения после преобразования
test_image_gray(deblurred_drunet_gray_image, shape_size=8, title='Результат обработки изображения после удаления блюра при помощи модели DRU-net_(gray)')
Проверка показаний SSIM:
ssim_value_noise = calculate_ssim(optimized_gray_image, blurred_gray_image, border=0)
print(f"SSIM (Original vs Blur): {ssim_value_noise:.4f}")
SSIM (Original vs Blur): 0.5960
ssim_value_denoised = calculate_ssim(optimized_gray_image, deblurred_drunet_gray_image, border=0)
print(f"SSIM (Original vs Deblurred): {ssim_value_denoised:.4f}")
SSIM (Original vs Deblurred): 0.5747
Проверка показаний PSNR:
psnr_value_noise = calculate_psnr(optimized_gray_image, blurred_gray_image, border=0)
print(f"PSNR (Original vs Blur): {psnr_value_noise:.2f} dB")
PSNR (Original vs Blur): 15.07 dB
psnr_value_denoised = calculate_psnr(optimized_gray_image, deblurred_drunet_gray_image, border=0)
print(f"PSNR (Original vs Deblurred): {psnr_value_denoised:.2f} dB")
PSNR (Original vs Deblurred): 14.80 dB
Реализцаия модели DRU-net (gray) для удаления эффекта дождя¶
# Применяем модель для удаления эффекта дождя
derained_drunet_gray_image = process_image_with_drunet_gray(drunet_model_gray, rainy_gray_image, 50, device)
# Сравнение изображений
compare_images(optimized_gray_image, rainy_gray_image, derained_drunet_gray_image, title='Обработка изображения моделью DRU-net_(gray)')
Проверка захвата горизонтальных линий на изображении
# Тест изображения c эффектом дождя
test_image_gray(rainy_gray_image, shape_size=4, title='Результат обработки изображения с эффектом дождя')
# Тест изображения после преобразования
test_image_gray(derained_drunet_gray_image, shape_size=4, title='Результат обработки изображения после удаления эффекта дождя при помощи модели DRU-net_(gray)')
Проверка показаний SSIM:
ssim_value_noise = calculate_ssim(optimized_gray_image, rainy_gray_image, border=0)
print(f"SSIM (Original vs Rainy): {ssim_value_noise:.4f}")
SSIM (Original vs Rainy): 0.8961
ssim_value_denoised = calculate_ssim(optimized_gray_image, derained_drunet_gray_image, border=0)
print(f"SSIM (Original vs Derained): {ssim_value_denoised:.4f}")
SSIM (Original vs Derained): 0.8925
Проверка показаний PSNR:
psnr_value_noise = calculate_psnr(optimized_gray_image, rainy_gray_image, border=0)
print(f"PSNR (Original vs Rainy): {psnr_value_noise:.2f} dB")
PSNR (Original vs Rainy): 19.17 dB
psnr_value_denoised = calculate_psnr(optimized_gray_image, derained_drunet_gray_image, border=0)
print(f"PSNR (Original vs Derained): {psnr_value_denoised:.2f} dB")
PSNR (Original vs Derained): 19.26 dB
Реализация моделей из статьи "Real-ESRGAN: Training Real-World Blind Super-Resolution with Pure Synthetic Data" (п. 20)¶
Страница на GitHub: https://github.com/ai-forever/Real-ESRGAN
Real-ESRGAN
Технология: GAN.
Особенности:
Использует генеративно-состязательный подход для моделирования сложных искажений.
Расширение ESRGAN для обработки изображений с неизвестными или сложными деградациями.
Синтетическое обучение с использованием модели деградации высокого порядка.
Преимущества:
Реалистичные визуальные результаты.
Эффективность для задач суперразрешения реальных изображений.
Обеспечивает стабильность обучения благодаря спектральной нормализации дискриминатора.
Ограничения:
Ограничена задачами суперразрешения.
Может генерировать артефакты в сложных случаях.
Клонирование репозитория с GitHub¶
!git clone https://github.com/ai-forever/Real-ESRGAN.git
%cd Real-ESRGAN
!pip install -r requirements.txt
!python setup.py develop
Cloning into 'Real-ESRGAN'...
remote: Enumerating objects: 96, done.
remote: Counting objects: 100% (33/33), done.
remote: Compressing objects: 100% (20/20), done.
remote: Total 96 (delta 14), reused 13 (delta 13), pack-reused 63 (from 1)
Receiving objects: 100% (96/96), 10.16 MiB | 27.60 MiB/s, done.
Resolving deltas: 100% (38/38), done.
/content/Real-ESRGAN
Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 1)) (1.26.4)
Requirement already satisfied: opencv-python in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 2)) (4.10.0.84)
Requirement already satisfied: Pillow in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 3)) (11.1.0)
Requirement already satisfied: torch>=1.7 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 4)) (2.5.1+cu121)
Requirement already satisfied: torchvision>=0.8.0 in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 5)) (0.20.1+cu121)
Requirement already satisfied: tqdm in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 6)) (4.67.1)
Requirement already satisfied: huggingface-hub in /usr/local/lib/python3.10/dist-packages (from -r requirements.txt (line 7)) (0.10.1)
Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from torch>=1.7->-r requirements.txt (line 4)) (3.16.1)
Requirement already satisfied: typing-extensions>=4.8.0 in /usr/local/lib/python3.10/dist-packages (from torch>=1.7->-r requirements.txt (line 4)) (4.12.2)
Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch>=1.7->-r requirements.txt (line 4)) (3.4.2)
Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch>=1.7->-r requirements.txt (line 4)) (3.1.5)
Requirement already satisfied: fsspec in /usr/local/lib/python3.10/dist-packages (from torch>=1.7->-r requirements.txt (line 4)) (2024.10.0)
Requirement already satisfied: sympy==1.13.1 in /usr/local/lib/python3.10/dist-packages (from torch>=1.7->-r requirements.txt (line 4)) (1.13.1)
Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from sympy==1.13.1->torch>=1.7->-r requirements.txt (line 4)) (1.3.0)
Requirement already satisfied: requests in /usr/local/lib/python3.10/dist-packages (from huggingface-hub->-r requirements.txt (line 7)) (2.32.3)
Requirement already satisfied: pyyaml>=5.1 in /usr/local/lib/python3.10/dist-packages (from huggingface-hub->-r requirements.txt (line 7)) (6.0.2)
Requirement already satisfied: packaging>=20.9 in /usr/local/lib/python3.10/dist-packages (from huggingface-hub->-r requirements.txt (line 7)) (24.2)
Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch>=1.7->-r requirements.txt (line 4)) (3.0.2)
Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests->huggingface-hub->-r requirements.txt (line 7)) (3.4.1)
Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests->huggingface-hub->-r requirements.txt (line 7)) (3.10)
Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests->huggingface-hub->-r requirements.txt (line 7)) (2.3.0)
Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests->huggingface-hub->-r requirements.txt (line 7)) (2024.12.14)
/content/Real-ESRGAN/setup.py:3: DeprecationWarning: pkg_resources is deprecated as an API. See https://setuptools.pypa.io/en/latest/pkg_resources.html
import pkg_resources
running develop
/usr/local/lib/python3.10/dist-packages/setuptools/command/develop.py:41: EasyInstallDeprecationWarning: easy_install command is deprecated.
!!
********************************************************************************
Please avoid running ``setup.py`` and ``easy_install``.
Instead, use pypa/build, pypa/installer or other
standards-based tools.
See https://github.com/pypa/setuptools/issues/917 for details.
********************************************************************************
!!
easy_install.initialize_options(self)
/usr/local/lib/python3.10/dist-packages/setuptools/_distutils/cmd.py:66: SetuptoolsDeprecationWarning: setup.py install is deprecated.
!!
********************************************************************************
Please avoid running ``setup.py`` directly.
Instead, use pypa/build, pypa/installer or other
standards-based tools.
See https://blog.ganssle.io/articles/2021/10/setup-py-deprecated.html for details.
********************************************************************************
!!
self.initialize_options()
running egg_info
creating RealESRGAN.egg-info
writing RealESRGAN.egg-info/PKG-INFO
writing dependency_links to RealESRGAN.egg-info/dependency_links.txt
writing requirements to RealESRGAN.egg-info/requires.txt
writing top-level names to RealESRGAN.egg-info/top_level.txt
writing manifest file 'RealESRGAN.egg-info/SOURCES.txt'
file RealESRGAN.py (for module RealESRGAN) not found
reading manifest file 'RealESRGAN.egg-info/SOURCES.txt'
adding license file 'LICENSE'
writing manifest file 'RealESRGAN.egg-info/SOURCES.txt'
running build_ext
Creating /usr/local/lib/python3.10/dist-packages/RealESRGAN.egg-link (link to .)
Adding RealESRGAN 1.0 to easy-install.pth file
Installed /content/Real-ESRGAN
Processing dependencies for RealESRGAN==1.0
Searching for huggingface-hub==0.10.1
Best match: huggingface-hub 0.10.1
Adding huggingface-hub 0.10.1 to easy-install.pth file
Installing huggingface-cli script to /usr/local/bin
Using /usr/local/lib/python3.10/dist-packages
Searching for tqdm==4.67.1
Best match: tqdm 4.67.1
Adding tqdm 4.67.1 to easy-install.pth file
Installing tqdm script to /usr/local/bin
Using /usr/local/lib/python3.10/dist-packages
Searching for torchvision==0.20.1+cu121
Best match: torchvision 0.20.1+cu121
Adding torchvision 0.20.1+cu121 to easy-install.pth file
Using /usr/local/lib/python3.10/dist-packages
Searching for torch==2.5.1+cu121
Best match: torch 2.5.1+cu121
Adding torch 2.5.1+cu121 to easy-install.pth file
Installing convert-caffe2-to-onnx script to /usr/local/bin
Installing convert-onnx-to-caffe2 script to /usr/local/bin
Installing torchfrtrace script to /usr/local/bin
Installing torchrun script to /usr/local/bin
Using /usr/local/lib/python3.10/dist-packages
Searching for pillow==11.1.0
Best match: pillow 11.1.0
Adding pillow 11.1.0 to easy-install.pth file
Using /usr/local/lib/python3.10/dist-packages
Searching for opencv-python==4.10.0.84
Best match: opencv-python 4.10.0.84
Adding opencv-python 4.10.0.84 to easy-install.pth file
Using /usr/local/lib/python3.10/dist-packages
Searching for numpy==1.26.4
Best match: numpy 1.26.4
Adding numpy 1.26.4 to easy-install.pth file
Installing f2py script to /usr/local/bin
Using /usr/local/lib/python3.10/dist-packages
Searching for packaging==24.2
Best match: packaging 24.2
Adding packaging 24.2 to easy-install.pth file
Using /usr/local/lib/python3.10/dist-packages
Searching for typing-extensions==4.12.2
Best match: typing-extensions 4.12.2
Adding typing-extensions 4.12.2 to easy-install.pth file
Using /usr/local/lib/python3.10/dist-packages/setuptools/_vendor
Searching for PyYAML==6.0.2
Best match: PyYAML 6.0.2
Adding PyYAML 6.0.2 to easy-install.pth file
detected new path './setuptools/_vendor'
Using /usr/local/lib/python3.10/dist-packages
Searching for requests==2.32.3
Best match: requests 2.32.3
Adding requests 2.32.3 to easy-install.pth file
Using /usr/local/lib/python3.10/dist-packages
Searching for filelock==3.16.1
Best match: filelock 3.16.1
Adding filelock 3.16.1 to easy-install.pth file
Using /usr/local/lib/python3.10/dist-packages
Searching for sympy==1.13.1
Best match: sympy 1.13.1
Adding sympy 1.13.1 to easy-install.pth file
Installing isympy script to /usr/local/bin
Using /usr/local/lib/python3.10/dist-packages
Searching for fsspec==2024.10.0
Best match: fsspec 2024.10.0
Adding fsspec 2024.10.0 to easy-install.pth file
Using /usr/local/lib/python3.10/dist-packages
Searching for jinja2==3.1.5
Best match: jinja2 3.1.5
Adding jinja2 3.1.5 to easy-install.pth file
Using /usr/local/lib/python3.10/dist-packages
Searching for networkx==3.4.2
Best match: networkx 3.4.2
Adding networkx 3.4.2 to easy-install.pth file
Using /usr/local/lib/python3.10/dist-packages
Searching for certifi==2024.12.14
Best match: certifi 2024.12.14
Adding certifi 2024.12.14 to easy-install.pth file
Using /usr/local/lib/python3.10/dist-packages
Searching for urllib3==2.3.0
Best match: urllib3 2.3.0
Adding urllib3 2.3.0 to easy-install.pth file
Using /usr/local/lib/python3.10/dist-packages
Searching for idna==3.10
Best match: idna 3.10
Adding idna 3.10 to easy-install.pth file
Using /usr/local/lib/python3.10/dist-packages
Searching for charset-normalizer==3.4.1
Best match: charset-normalizer 3.4.1
Adding charset-normalizer 3.4.1 to easy-install.pth file
Installing normalizer script to /usr/local/bin
Using /usr/local/lib/python3.10/dist-packages
Searching for mpmath==1.3.0
Best match: mpmath 1.3.0
Adding mpmath 1.3.0 to easy-install.pth file
Using /usr/local/lib/python3.10/dist-packages
Searching for MarkupSafe==3.0.2
Best match: MarkupSafe 3.0.2
Adding MarkupSafe 3.0.2 to easy-install.pth file
Using /usr/local/lib/python3.10/dist-packages
Finished processing dependencies for RealESRGAN==1.0
from RealESRGAN import RealESRGAN
/content/Real-ESRGAN/RealESRGAN/model.py:59: FutureWarning: `torch.cuda.amp.autocast(args...)` is deprecated. Please use `torch.amp.autocast('cuda', args...)` instead.
@torch.cuda.amp.autocast()
/usr/local/lib/python3.10/dist-packages/torch/amp/autocast_mode.py:266: UserWarning: User provided device_type of 'cuda', but CUDA is not available. Disabling
warnings.warn(
%cd ..
/content
Загрузка весов моделей¶
file_id = '1pG2S3sYvSaO0V0B8QPOl1RapPHpUGOaV'
gdown.download(f'https://drive.google.com/uc?id={file_id}', 'RealESRGAN_x2.pth', quiet=False)
Downloading... From (original): https://drive.google.com/uc?id=1pG2S3sYvSaO0V0B8QPOl1RapPHpUGOaV From (redirected): https://drive.google.com/uc?id=1pG2S3sYvSaO0V0B8QPOl1RapPHpUGOaV&confirm=t&uuid=faa5557b-0db0-43c6-b004-759856ce3370 To: /content/RealESRGAN_x2.pth 100%|██████████| 67.1M/67.1M [00:01<00:00, 66.2MB/s]
'RealESRGAN_x2.pth'
file_id = '1SGHdZAln4en65_NQeQY9UjchtkEF9f5F'
gdown.download(f'https://drive.google.com/uc?id={file_id}', 'RealESRGAN_x4.pth', quiet=False)
Downloading... From (original): https://drive.google.com/uc?id=1SGHdZAln4en65_NQeQY9UjchtkEF9f5F From (redirected): https://drive.google.com/uc?id=1SGHdZAln4en65_NQeQY9UjchtkEF9f5F&confirm=t&uuid=aa79629b-1ba8-45e1-a57f-6a888dba2a62 To: /content/RealESRGAN_x4.pth 100%|██████████| 67.0M/67.0M [00:01<00:00, 49.8MB/s]
'RealESRGAN_x4.pth'
file_id = '1mT9ewx86PSrc43b-ax47l1E2UzR7Ln4j'
gdown.download(f'https://drive.google.com/uc?id={file_id}', 'RealESRGAN_x8.pth', quiet=False)
Downloading... From (original): https://drive.google.com/uc?id=1mT9ewx86PSrc43b-ax47l1E2UzR7Ln4j From (redirected): https://drive.google.com/uc?id=1mT9ewx86PSrc43b-ax47l1E2UzR7Ln4j&confirm=t&uuid=4a703277-2f8b-407c-9267-c14fa036668c To: /content/RealESRGAN_x8.pth 100%|██████████| 67.2M/67.2M [00:00<00:00, 71.0MB/s]
'RealESRGAN_x8.pth'
# Путь к весам моделей
model_path_x2 = "RealESRGAN_x2.pth"
model_path_x4 = "RealESRGAN_x4.pth"
model_path_x8 = "RealESRGAN_x8.pth"
Инициализация функций¶
def upscale_image_with_realesrgan(model_path, input_image, scale=2):
"""
Применение Real-ESRGAN для увеличения разрешения изображения.
:param model_path: Путь к весам модели Real-ESRGAN
:param input_image: Изображение в формате NumPy массива или PIL.Image
:param scale: Коэффициент увеличения (по умолчанию 8)
:return: Увеличенное изображение (PIL.Image)
"""
# Устройство для вычислений
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# Инициализация модели
model = RealESRGAN(device, scale=scale)
# Загрузка весов
model.load_weights(model_path)
# Если изображение передано как NumPy массив, преобразуем его в PIL.Image
if isinstance(input_image, np.ndarray):
input_image = Image.fromarray(cv2.cvtColor(input_image, cv2.COLOR_BGR2RGB))
# Увеличение разрешения
with torch.no_grad():
output_image = model.predict(input_image)
return output_image
def compare_image_params(original_image, enhanced_image):
"""
Сравнивает параметры двух изображений.
:param original_image: Исходное изображение (NumPy массив)
:param enhanced_image: Улучшенное изображение (PIL.Image или NumPy массив)
:return: Словарь с результатами сравнения
"""
# Преобразуем улучшенное изображение в NumPy массив, если оно в формате PIL.Image
if not isinstance(enhanced_image, np.ndarray):
enhanced_image = np.array(enhanced_image)
# Размеры изображений
original_height, original_width = original_image.shape[:2]
enhanced_height, enhanced_width = enhanced_image.shape[:2]
# Изменение размера улучшенного изображения до размера оригинала
if (original_width, original_height) != (enhanced_width, enhanced_height):
print("Размеры изображений не совпадают. Изменяем размер улучшенного изображения.")
# Масштабируем улучшенное изображение до размеров оригинала
enhanced_image = cv2.resize(enhanced_image, (original_width, original_height), interpolation=cv2.INTER_LINEAR)
# Количество пикселей
original_pixels = original_height * original_width
enhanced_pixels = enhanced_height * enhanced_width
# Минимум, максимум, среднее
original_min, original_max, original_mean = original_image.min(), original_image.max(), original_image.mean()
enhanced_min, enhanced_max, enhanced_mean = enhanced_image.min(), enhanced_image.max(), enhanced_image.mean()
# Гистограммы
original_hist = cv2.calcHist([original_image], [0], None, [256], [0, 256])
enhanced_hist = cv2.calcHist([enhanced_image], [0], None, [256], [0, 256])
# SSIM между оригиналом и улучшенным изображением
ssim_value = ssim(original_image, enhanced_image, multichannel=True, win_size=3)
# Расчет PSNR между оригинальным и улучшенным изображением
psnr_value = cv2.PSNR(original_image, enhanced_image)
# Результаты сравнения
results = {
"Размеры (original)": f"{original_width}x{original_height}",
"Размеры (enhanced)": f"{enhanced_width}x{enhanced_height}",
"Количество пикселей (original)": original_pixels,
"Количество пикселей (enhanced)": enhanced_pixels,
"Минимум, максимум, среднее (original)": (original_min, original_max, original_mean),
"Минимум, максимум, среднее (enhanced)": (enhanced_min, enhanced_max, enhanced_mean),
"SSIM": ssim_value,
"PSNR": f"{psnr_value:.2f} dB",
"Гистограмма (original)": original_hist,
"Гистограмма (enhanced)": enhanced_hist,
}
return results
# Функция для сравнения параметров изображений
def compare_and_print_params(input_image, enhanced_image, scale):
"""
Сравнивает параметры двух изображений и выводит ключевые характеристики.
:param input_image: Оригинальное изображение (NumPy массив)
:param enhanced_image: Увеличенное изображение (NumPy массив)
:param scale: Коэффициент увеличения (x2, x4 или x8)
"""
# Сравниваем параметры
params_comparison = compare_image_params(cv2.cvtColor(input_image, cv2.COLOR_BGR2RGB), enhanced_image)
# Выводим ключевые параметры
print(f"Сравнение параметров изображений для x{scale}:")
for key, value in params_comparison.items():
if "Гистограмма" in key:
continue
print(f"{key}: {value}")
print("\n")
Реализация модели Real-ESRGAN x2 для удаления шума¶
# Применяем модель Real-ESRGAN x2
denoised_image_esrgan_x2 = upscale_image_with_realesrgan(model_path_x2, input_image=noisy_color_image, scale=2)
/content/Real-ESRGAN/RealESRGAN/model.py:49: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature. loadnet = torch.load(model_path)
denoised_image_esrgan_x2_np = np.array(denoised_image_esrgan_x2)
# Сравнение изображений
compare_images(optimized_color_image, noisy_color_image, denoised_image_esrgan_x2_np, title='Обработка изображения моделью Real-ESRGAN x2')
# Сравнение параметров изображений
compare_and_print_params(optimized_color_image, denoised_image_esrgan_x2, scale=2)
Размеры изображений не совпадают. Изменяем размер улучшенного изображения. Сравнение параметров изображений для x2: Размеры (original): 1280x384 Размеры (enhanced): 2560x768 Количество пикселей (original): 491520 Количество пикселей (enhanced): 1966080 Минимум, максимум, среднее (original): (0, 255, 232.49093763563368) Минимум, максимум, среднее (enhanced): (0, 255, 232.37723863389758) SSIM: 0.9264955074374116 PSNR: 26.43 dB
ssim_value_noise = calculate_ssim(optimized_color_image, noisy_color_image, border=0)
print(f"SSIM (Original vs Noise): {ssim_value_noise:.4f}")
SSIM (Original vs Noise): 0.3647
psnr_value_noise = calculate_psnr(optimized_color_image, noisy_color_image, border=0)
print(f"PSNR (Original vs Noise): {psnr_value_noise:.2f} dB")
PSNR (Original vs Noise): 16.72 dB
Проверка захвата горизонтальных и вертикальных линий
# Тест изображения с шумом
test_image(noisy_color_image, shape_size=8, title='Результат обработки изображения с шумом')
# Тест изображения после обработки моделью х2
test_image(denoised_image_esrgan_x2_np, shape_size=8, title='Результат обработки изображения после применения модели Real-ESRGAN x2')
Реализация модели Real-ESRGAN x2 для удаления блюра¶
# Применяем модель Real-ESRGAN x2
deblurred_image_esrgan_x2 = upscale_image_with_realesrgan(model_path_x2, input_image=blurred_color_image, scale=2)
/content/Real-ESRGAN/RealESRGAN/model.py:49: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature. loadnet = torch.load(model_path)
deblurred_image_esrgan_x2_np = np.array(deblurred_image_esrgan_x2)
# Сравнение изображений
compare_images(optimized_color_image, blurred_color_image, deblurred_image_esrgan_x2_np, title='Обработка изображения моделью Real-ESRGAN x2')
# Сравнение параметров изображений
compare_and_print_params(optimized_color_image, deblurred_image_esrgan_x2, scale=2)
Размеры изображений не совпадают. Изменяем размер улучшенного изображения. Сравнение параметров изображений для x2: Размеры (original): 1280x384 Размеры (enhanced): 2560x768 Количество пикселей (original): 491520 Количество пикселей (enhanced): 1966080 Минимум, максимум, среднее (original): (0, 255, 232.49093763563368) Минимум, максимум, среднее (enhanced): (0, 255, 229.0857401529948) SSIM: 0.8440234520014331 PSNR: 18.55 dB
ssim_value_noise = calculate_ssim(optimized_color_image, blurred_color_image, border=0)
print(f"SSIM (Original vs Blur): {ssim_value_noise:.4f}")
SSIM (Original vs Blur): 0.5960
psnr_value_noise = calculate_psnr(optimized_color_image, blurred_color_image, border=0)
print(f"PSNR (Original vs Blur): {psnr_value_noise:.2f} dB")
PSNR (Original vs Blur): 15.07 dB
Проверка захвата горизонтальных и вертикальных линий
# Тест изображения с блюром
test_image(blurred_color_image, shape_size=8, title='Результат обработки изображения с блюром')
# Тест изображения после обработки моделью х2
test_image(deblurred_image_esrgan_x2_np, shape_size=8, title='Результат обработки изображения после применения модели Real-ESRGAN x2')
Реализация модели Real-ESRGAN x2 для удаления эффекта дождя¶
# Применяем модель Real-ESRGAN x2
derained_image_esrgan_x2 = upscale_image_with_realesrgan(model_path_x2, input_image=rainy_color_image, scale=2)
derained_image_esrgan_x2_np = np.array(derained_image_esrgan_x2)
# Сравнение изображений
compare_images(optimized_color_image, rainy_color_image, derained_image_esrgan_x2_np, title='Обработка изображения моделью Real-ESRGAN x2')
# Сравнение параметров изображений
compare_and_print_params(optimized_color_image, derained_image_esrgan_x2, scale=2)
Размеры изображений не совпадают. Изменяем размер улучшенного изображения. Сравнение параметров изображений для x2: Размеры (original): 1280x384 Размеры (enhanced): 2560x768 Количество пикселей (original): 491520 Количество пикселей (enhanced): 1966080 Минимум, максимум, среднее (original): (0, 255, 232.49093763563368) Минимум, максимум, среднее (enhanced): (0, 255, 244.3879380967882) SSIM: 0.8636780824496706 PSNR: 18.13 dB
ssim_value_noise = calculate_ssim(optimized_color_image, rainy_color_image, border=0)
print(f"SSIM (Original vs Rainy): {ssim_value_noise:.4f}")
SSIM (Original vs Rainy): 0.8959
psnr_value_noise = calculate_psnr(optimized_color_image, rainy_color_image, border=0)
print(f"PSNR (Original vs Rainy): {psnr_value_noise:.2f} dB")
PSNR (Original vs Blur): 15.07 dB
Проверка захвата горизонтальных и вертикальных линий
# Тест изображения с эффектом дождя
test_image(rainy_color_image, shape_size=8, title='Результат обработки изображения с эффектом дождя')
# Тест изображения после обработки моделью х2
test_image(derained_image_esrgan_x2_np, shape_size=8, title='Результат обработки изображения после применения модели Real-ESRGAN x2')
